diff --git a/app.py b/app.py
index ade4e17..ea1996b 100644
--- a/app.py
+++ b/app.py
@@ -1,661 +1,666 @@
 # -*- coding: utf-8 -*-
 
 import bs4 # type: ignore
 import cachetools
 import datetime
 import flask
 import humanize
 import mwapi # type: ignore
 import mwoauth # type: ignore
 import os
 import random
 import re
 import requests_oauthlib # type: ignore
 import string
 import threading
 import toolforge
 import traceback
 from typing import Any, List, Optional, Tuple, Type, Union
 import werkzeug.wsgi
 import yaml
 
 from batch import StoredBatch, OpenBatch
-from command import Command, CommandRecord, CommandPlan, CommandPending, CommandEdit, CommandNoop, CommandFailure, CommandPageMissing, CommandPageProtected, CommandEditConflict, CommandMaxlagExceeded, CommandBlocked, CommandWikiReadOnly
+from command import Command, CommandRecord, CommandPlan, CommandPending, CommandEdit, CommandNoop, CommandFailure, CommandPageMissing, CommandTitleInvalid, CommandPageProtected, CommandEditConflict, CommandMaxlagExceeded, CommandBlocked, CommandWikiReadOnly
 from localuser import LocalUser
 import parse_wikitext
 import parse_tpsv
 from querytime import QueryTimingCursor, flush_querytime, slow_queries, query_summary
 from runner import Runner
 from store import BatchStore
 from timestamp import now
 
 
 app = flask.Flask(__name__)
 
 user_agent = toolforge.set_user_agent('quickcategories', email='mail@lucaswerkmeister.de')
 
 __dir__ = os.path.dirname(__file__)
 try:
     with open(os.path.join(__dir__, 'config.yaml')) as config_file:
         app.config.update(yaml.safe_load(config_file))
 except FileNotFoundError:
     print('config.yaml file not found, assuming local development setup')
     app.secret_key = ''.join(random.choice(string.ascii_letters + string.digits) for _ in range(64))
 
 if 'oauth' in app.config:
     consumer_token = mwoauth.ConsumerToken(app.config['oauth']['consumer_key'], app.config['oauth']['consumer_secret'])
 
 if 'database' in app.config:
     from database import DatabaseStore
     app.config['database']['cursorclass'] = QueryTimingCursor
     batch_store = DatabaseStore(app.config['database']) # type: BatchStore
 
     def sometimes_flush_querytime():
         if random.randrange(128) == 0:
             with batch_store.connect() as connection:
                 flush_querytime(connection)
 
     class SometimesFlushQuerytimeMiddleware:
         def __init__(self, app):
             self.app = app
 
         def __call__(self, environ, start_response):
             return werkzeug.wsgi.ClosingIterator(self.app(environ, start_response), sometimes_flush_querytime)
 
     app.wsgi_app = SometimesFlushQuerytimeMiddleware(app.wsgi_app) # type: ignore # “cannot assign to a method”
 else:
     from in_memory import InMemoryStore
     print('No database configuration, using in-memory store (batches will be lost on every restart)')
     batch_store = InMemoryStore()
 
 stewards_global_user_ids_cache = cachetools.TTLCache(maxsize=1, ttl=24*60*60) # type: cachetools.TTLCache[Any, List[int]]
 stewards_global_user_ids_cache_lock = threading.RLock()
 
 
 def log(type, message):
     if app.config.get('DEBUG_' + type, False):
         print('[%s] %s' % (type, message))
 
 
 @app.template_global()
 def csrf_token() -> str:
     if 'csrf_token' not in flask.session:
         log('CSRF', 'allocating a new token')
         flask.session['csrf_token'] = ''.join(random.choice(string.ascii_letters + string.digits) for _ in range(64))
     else:
         log('CSRF', 'reusing token from session')
     return flask.session['csrf_token']
 
 @app.template_global()
 def form_value(name: str) -> flask.Markup:
     if 'repeat_form' in flask.g and name in flask.request.form:
         return (flask.Markup(r' value="') +
                 flask.Markup.escape(flask.request.form[name]) +
                 flask.Markup(r'" '))
     else:
         return flask.Markup()
 
 @app.template_global()
 def form_attributes(name: str) -> flask.Markup:
     return (flask.Markup(r' id="') +
             flask.Markup.escape(name) +
             flask.Markup(r'" name="') +
             flask.Markup.escape(name) +
             flask.Markup(r'" ') +
             form_value(name))
 
 @app.template_filter()
 def user_link(user_name: str) -> flask.Markup:
     return (flask.Markup(r'<a href="https://meta.wikimedia.org/wiki/User:') +
             flask.Markup.escape(user_name.replace(' ', '_')) +
             flask.Markup(r'">') +
             flask.Markup(r'<bdi>') +
             flask.Markup.escape(user_name) +
             flask.Markup(r'</bdi>') +
             flask.Markup(r'</a>'))
 
 @app.template_global()
 def user_logged_in() -> bool:
     return authenticated_session() is not None
 
 @app.template_global()
 def authentication_area() -> flask.Markup:
     if 'oauth' not in app.config:
         return flask.Markup()
 
     if 'oauth_access_token' not in flask.session:
         return (flask.Markup(r'<a id="login" class="navbar-text" href="') +
                 flask.Markup.escape(flask.url_for('login')) +
                 flask.Markup(r'">Log in</a>'))
 
     access_token = mwoauth.AccessToken(**flask.session['oauth_access_token'])
     identity = mwoauth.identify('https://meta.wikimedia.org/w/index.php',
                                 consumer_token,
                                 access_token)
 
     return (flask.Markup(r'<span class="navbar-text">Logged in as ') +
             user_link(identity['username']) +
             flask.Markup(r'</span>'))
 
 @app.template_global()
 def can_run_commands(command_records: List[CommandRecord]) -> bool:
     return flask.g.can_run_commands and any(filter(lambda command_record: isinstance(command_record, CommandPlan), command_records))
 
 @app.template_global()
 def can_start_background() -> bool:
     return flask.g.can_start_background
 
 @app.template_global()
 def can_stop_background() -> bool:
     return flask.g.can_stop_background
 
 @app.template_global() # TODO make domain part of Command and turn this into a template filter?
 def render_command(command: Command, domain: str) -> flask.Markup:
     return flask.Markup(flask.render_template('command.html',
                                               domain=domain,
                                               command=command))
 
 @app.template_global() # TODO also turn into a template filter?
 def render_command_record(command_record: CommandRecord, domain: str) -> flask.Markup:
     if isinstance(command_record, CommandPlan):
         command_record_markup = flask.render_template('command_plan.html',
                                                       domain=domain,
                                                       command_plan=command_record)
     elif isinstance(command_record, CommandPending):
         command_record_markup = flask.render_template('command_pending.html',
                                                       domain=domain,
                                                       command_pending=command_record)
     elif isinstance(command_record, CommandEdit):
         command_record_markup = flask.render_template('command_edit.html',
                                                       domain=domain,
                                                       command_edit=command_record)
     elif isinstance(command_record, CommandNoop):
         command_record_markup = flask.render_template('command_noop.html',
                                                       domain=domain,
                                                       command_noop=command_record)
     elif isinstance(command_record, CommandPageMissing):
         command_record_markup = flask.render_template('command_page_missing.html',
                                                       domain=domain,
                                                       command_page_missing=command_record)
+    elif isinstance(command_record, CommandTitleInvalid):
+        command_record_markup = flask.render_template('command_title_invalid.html',
+                                                      domain=domain,
+                                                      command_title_invalid=command_record)
     elif isinstance(command_record, CommandPageProtected):
         command_record_markup = flask.render_template('command_page_protected.html',
                                                       domain=domain,
                                                       command_page_protected=command_record)
     elif isinstance(command_record, CommandEditConflict):
         command_record_markup = flask.render_template('command_edit_conflict.html',
                                                       domain=domain,
                                                       command_edit_conflict=command_record)
     elif isinstance(command_record, CommandMaxlagExceeded):
         command_record_markup = flask.render_template('command_maxlag_exceeded.html',
                                                       domain=domain,
                                                       command_maxlag_exceeded=command_record)
     elif isinstance(command_record, CommandBlocked):
         command_record_markup = flask.render_template('command_blocked.html',
                                                       domain=domain,
                                                       command_blocked=command_record)
     elif isinstance(command_record, CommandWikiReadOnly):
         command_record_markup = flask.render_template('command_wiki_read_only.html',
                                                       domain=domain,
                                                       command_blocked=command_record)
     else:
         raise ValueError('Unknown command record type')
 
     return flask.Markup(command_record_markup)
 
 @app.template_filter()
 def render_command_record_type(command_record_type: Type[CommandRecord]) -> flask.Markup:
     template_names = {
         CommandPlan: 'command_plan_badge.html',
         CommandPending: 'command_pending_badge.html',
         CommandEdit: 'command_edit_badge.html',
         CommandNoop: 'command_noop_badge.html',
         CommandPageMissing: 'command_page_missing_badge.html',
+        CommandTitleInvalid: 'command_title_invalid_badge.html',
         CommandPageProtected: 'command_page_protected_badge.html',
         CommandEditConflict: 'command_edit_conflict_badge.html',
         CommandMaxlagExceeded: 'command_maxlag_exceeded_badge.html',
         CommandBlocked: 'command_blocked_badge.html',
         CommandWikiReadOnly: 'command_wiki_read_only_badge.html',
     }
     template_name = template_names[command_record_type]
     return flask.Markup(flask.render_template(template_name))
 
 @app.template_filter()
 def render_datetime(dt: datetime.datetime) -> flask.Markup:
     naive_dt = dt.astimezone().replace(tzinfo=None) # humanize doesn’t support timezones :(
     return (flask.Markup(r'<time datetime="') +
             flask.Markup.escape(dt.isoformat()) +
             flask.Markup(r'" title="') +
             flask.Markup.escape(dt.isoformat()) +
             flask.Markup(r'">') +
             flask.Markup.escape(humanize.naturaltime(naive_dt)) +
             flask.Markup(r'</time>'))
 
 @app.template_global()
 def render_local_user(local_user: LocalUser) -> flask.Markup:
     return (flask.Markup(r'<a href="https://') +
             flask.Markup.escape(local_user.domain) +
             flask.Markup(r'/wiki/Special:Redirect/user/') +
             flask.Markup.escape(str(local_user.local_user_id)) +
             flask.Markup(r'"><bdi>') +
             flask.Markup.escape(local_user.user_name) +
             flask.Markup(r'</bdi></a>'))
 
 @app.template_global()
 def render_batch_title(batch: StoredBatch) -> Optional[flask.Markup]:
     if not batch.title:
         return None
     return parse_wikitext.parse_summary(anonymous_session(batch.domain), batch.title)
 
 @app.template_filter()
 def html_text(html: Union[str, flask.Markup]) -> flask.Markup:
     soup = bs4.BeautifulSoup(html, 'html.parser')
     text = soup.text
     return flask.Markup.escape(text)
 
 @app.template_global()
 def render_batch_title_text(batch: StoredBatch) -> Optional[flask.Markup]:
     title_html = render_batch_title(batch)
     if not title_html:
         return None
     return html_text(title_html)
 
 def authenticated_session(domain: str = 'meta.wikimedia.org') -> Optional[mwapi.Session]:
     if 'oauth_access_token' in flask.session:
         access_token = mwoauth.AccessToken(**flask.session['oauth_access_token'])
         auth = requests_oauthlib.OAuth1(client_key=consumer_token.key, client_secret=consumer_token.secret,
                                         resource_owner_key=access_token.key, resource_owner_secret=access_token.secret)
         return mwapi.Session(host='https://'+domain, auth=auth, user_agent=user_agent)
     else:
         return None
 
 def anonymous_session(domain: str = 'meta.wikimedia.org') -> mwapi.Session:
     return mwapi.Session(host='https://'+domain, user_agent=user_agent)
 
 def any_session(domain: str = 'meta.wikimedia.org') -> mwapi.Session:
     return authenticated_session(domain) or anonymous_session(domain)
 
 @app.route('/')
 def index():
     return flask.render_template('index.html', batches=batch_store.get_batches_slice(offset=0, limit=10))
 
 @app.route('/batch', methods=['POST'])
 def new_batch():
     if not submitted_request_valid():
         return 'CSRF error', 400
 
     domain = flask.request.form.get('domain', '(not provided)')
     if not is_wikimedia_domain(domain):
         return flask.Markup.escape(domain) + flask.Markup(' is not recognized as a Wikimedia domain'), 400
 
     title = flask.request.form.get('title')
     if title is not None and len(title) > 800:
         return flask.Markup('Title "') + flask.Markup.escape(title) + flask.Markup('" is too long for a summary'), 400
 
     session = authenticated_session(domain)
     if not session:
         return 'not logged in', 403 # Forbidden; 401 Unauthorized would be inappropriate because we don’t send WWW-Authenticate
 
     try:
         response = session.get(action='query',
                                meta='siteinfo')
         servername = response['query']['general']['servername']
         if servername != domain:
             message = (flask.Markup(r'The server at <code>') +
                        flask.Markup.escape(domain) +
                        flask.Markup(r'</code> indicates its actual name is <code>') +
                        flask.Markup.escape(servername) +
                        flask.Markup(r'</code>.'))
             return flask.render_template('new_batch_error.html',
                                          message=message), 400
     except Exception:
         traceback.print_exc() # for possible later manual inspection
         message = (flask.Markup(r'Could not connect to the server at <code>') +
                    flask.Markup.escape(domain) +
                    flask.Markup(r'</code>.'))
         return flask.render_template('new_batch_error.html',
                                      message=message), 400
 
     try:
         batch = parse_tpsv.parse_batch(flask.request.form.get('commands', ''), title=title)
     except parse_tpsv.ParseBatchError as e:
         return str(e)
 
     batch.cleanup()
 
     id = batch_store.store_batch(batch, session).id
     return flask.redirect(flask.url_for('batch', id=id))
 
 @app.route('/batch/')
 def batches():
     offset, limit = slice_from_args(flask.request.args)
     return flask.render_template('batches.html',
                                  batches=batch_store.get_batches_slice(offset=offset, limit=limit),
                                  offset=offset,
                                  limit=limit,
                                  count=batch_store.get_batches_count())
 
 @app.route('/batch/<int:id>/')
 def batch(id: int):
     batch = batch_store.get_batch(id)
     if batch is None:
         return flask.render_template('batch_not_found.html',
                                      id=id), 404
 
     session = authenticated_session(batch.domain)
     if session:
         try:
             userinfo = session.get(action='query',
                                    meta='userinfo',
                                    uiprop=['groups', 'centralids'])['query']['userinfo']
         except mwapi.errors.APIError as e:
             if e.code == 'mwoauth-invalid-authorization-invalid-user':
                 # user is viewing a batch for a wiki where they do not have a local user account
                 # treat as anonymous on the local wiki, but query Meta to find out if they’re a steward
                 local_user_id = None # type: Optional[int]
                 groups = [] # type: List[str]
                 meta_session = authenticated_session('meta.wikimedia.org') # type: mwapi.Session
                 meta_userinfo = meta_session.get(action='query',
                                                  meta='userinfo',
                                                  uiprop=['centralids'])['query']['userinfo']
                 global_user_id = meta_userinfo['centralids']['CentralAuth']
             else:
                 raise e
         else:
             local_user_id = userinfo['id']
             groups = userinfo['groups']
             global_user_id = userinfo['centralids']['CentralAuth']
         flask.g.can_run_commands = local_user_id == batch.local_user.local_user_id
         flask.g.can_start_background = flask.g.can_run_commands and \
             'autoconfirmed' in groups and \
             isinstance(batch, OpenBatch)
         flask.g.can_stop_background = flask.g.can_start_background or \
             'sysop' in groups or \
             global_user_id in steward_global_user_ids()
     else:
         flask.g.can_run_commands = False
         flask.g.can_start_background = False
         flask.g.can_stop_background = False
 
     offset, limit = slice_from_args(flask.request.args)
 
     return flask.render_template('batch.html',
                                  batch=batch,
                                  offset=offset,
                                  limit=limit)
 
 @app.route('/batch/<int:id>/background_history')
 def batch_background_history(id: int):
     batch = batch_store.get_batch(id)
     if batch is None:
         return flask.render_template('batch_not_found.html',
                                      id=id), 404
 
     return flask.render_template('background_history.html',
                                  batch=batch)
 
 @app.route('/batch/<int:id>/run_slice', methods=['POST'])
 def run_batch_slice(id: int):
     if not submitted_request_valid():
         return 'CSRF error', 400
 
     batch = batch_store.get_batch(id)
     if batch is None:
         return flask.render_template('batch_not_found.html',
                                      id=id), 404
 
     session = authenticated_session(batch.domain)
     if not session:
         return 'not logged in', 403
     local_user_id = session.get(action='query',
                                 meta='userinfo')['query']['userinfo']['id']
     if local_user_id != batch.local_user.local_user_id:
         return 'may not run this batch', 403
 
     if 'summary_batch_link' in app.config:
         summary_batch_link = app.config['summary_batch_link'].format(id)
     else:
         summary_batch_link = None
 
     runner = Runner(session, batch.title, summary_batch_link)
 
     offset, limit = slice_from_args(flask.request.form)
     command_pendings = batch.command_records.make_plans_pending(offset, limit)
 
     try:
         runner.prepare_pages([command_pending.command.page for command_pending in command_pendings])
         for command_pending in command_pendings:
             for attempt in range(5):
                 command_finish = runner.run_command(command_pending)
                 if isinstance(command_finish, CommandFailure) and command_finish.can_retry_immediately():
                     continue
                 else:
                     break
             batch.command_records.store_finish(command_finish)
             if isinstance(command_finish, CommandFailure):
                 can_continue = command_finish.can_continue_batch()
                 if isinstance(can_continue, datetime.datetime):
                     batch_store.suspend_background(batch, until=can_continue)
                     break
                 elif not can_continue:
                     batch_store.stop_background(batch)
                     break
     finally:
         batch.command_records.make_pendings_planned([command_pending.id for command_pending in command_pendings])
 
     return flask.redirect(flask.url_for('batch',
                                         id=id,
                                         offset=offset,
                                         limit=limit))
 
 @app.route('/batch/<int:id>/start_background', methods=['POST'])
 def start_batch_background(id: int):
     if not submitted_request_valid():
         return 'CSRF error', 400
 
     batch = batch_store.get_batch(id)
     if batch is None:
         return flask.render_template('batch_not_found.html',
                                      id=id), 404
     if not isinstance(batch, OpenBatch):
         return 'not an open batch', 400
 
     session = authenticated_session(batch.domain)
     if not session:
         return 'not logged in', 403
     userinfo = session.get(action='query',
                            meta='userinfo',
                            uiprop=['groups'])['query']['userinfo']
     local_user_id = userinfo['id']
     if local_user_id != batch.local_user.local_user_id or \
        'autoconfirmed' not in userinfo['groups']:
         return 'may not start this batch in background', 403
 
     batch_store.start_background(batch, session)
 
     offset, limit = slice_from_args(flask.request.form)
     return flask.redirect(flask.url_for('batch',
                                         id=id,
                                         offset=offset,
                                         limit=limit))
 
 @app.route('/batch/<int:id>/stop_background', methods=['POST'])
 def stop_batch_background(id: int):
     if not submitted_request_valid():
         return 'CSRF error', 400
 
     batch = batch_store.get_batch(id)
     if batch is None:
         return flask.render_template('batch_not_found.html',
                                      id=id), 404
 
     session = authenticated_session(batch.domain)
     if not session:
         return 'not logged in', 403
     userinfo = session.get(action='query',
                            meta='userinfo',
                            uiprop=['groups', 'centralids'])['query']['userinfo']
     local_user_id = userinfo['id']
     global_user_id = userinfo['centralids']['CentralAuth']
     if local_user_id != batch.local_user.local_user_id and \
        'sysop' not in userinfo['groups'] and \
        global_user_id not in steward_global_user_ids():
         return 'may not stop this batch in background', 403
 
     batch_store.stop_background(batch, session)
 
     offset, limit = slice_from_args(flask.request.form)
     return flask.redirect(flask.url_for('batch',
                                         id=id,
                                         offset=offset,
                                         limit=limit))
 
 @app.route('/login')
 def login():
     redirect, request_token = mwoauth.initiate('https://meta.wikimedia.org/w/index.php', consumer_token, user_agent=user_agent)
     flask.session['oauth_request_token'] = dict(zip(request_token._fields, request_token))
     return flask.redirect(redirect)
 
 @app.route('/oauth/callback')
 def oauth_callback():
     request_token = mwoauth.RequestToken(**flask.session.pop('oauth_request_token'))
     access_token = mwoauth.complete('https://meta.wikimedia.org/w/index.php', consumer_token, request_token, flask.request.query_string, user_agent=user_agent)
     flask.session['oauth_access_token'] = dict(zip(access_token._fields, access_token))
     return flask.redirect(flask.url_for('index'))
 
 @app.route('/debug/query_times')
 def query_times():
     session = authenticated_session()
     if not session:
         return 'not logged in', 403
 
     allowed_global_user_ids = [
         46054761,
     ]
     userinfo = session.get(action='query',
                            meta='userinfo',
                            uiprop=['centralids'])['query']['userinfo']
     if userinfo['centralids']['CentralAuth'] not in allowed_global_user_ids:
         return 'not allowed', 403
 
     if not isinstance(batch_store, DatabaseStore):
         return '', 204 # no content
 
     until = now()
     since = until - datetime.timedelta(days=7)
 
     leading_spaces = re.compile(r'^\s+', re.MULTILINE)
     with batch_store.connect() as connection:
         flush_querytime(connection)
         slowest_queries = [(t, duration, re.sub(leading_spaces, '', sql))
                            for t, duration, sql in slow_queries(connection, since, until)]
         summary = query_summary(connection, since, until)
         for index, (sql, stats) in enumerate(summary):
             sql = re.sub(leading_spaces, '', sql)
             summary[index] = (sql, stats)
     return flask.render_template('query_times.html',
                                  since=since,
                                  until=until,
                                  slowest_queries=slowest_queries,
                                  summary=summary)
 
 
 def is_wikimedia_domain(domain: str) -> bool:
     return re.fullmatch(r'[a-z0-9-]+\.(?:wiki(?:pedia|media|books|data|news|quote|source|versity|voyage)|mediawiki|wiktionary)\.org', domain) is not None
 
 def slice_from_args(args: dict) -> Tuple[int, int]:
     try:
         offset = int(args['offset'])
     except (KeyError, ValueError):
         offset = 0
     offset = max(0, offset)
 
     try:
         limit = int(args['limit'])
     except (KeyError, ValueError):
         limit = 50
     limit = max(1, min(500, limit))
 
     return offset, limit
 
 @cachetools.cached(cache=stewards_global_user_ids_cache,
                    key=lambda: '#stewards',
                    lock=stewards_global_user_ids_cache_lock)
 def steward_global_user_ids() -> List[int]:
     session = mwapi.Session(host='https://meta.wikimedia.org', user_agent=user_agent)
     ids = []
     for result in session.get(action='query',
                               list='allusers',
                               augroup=['steward'],
                               auprop=['centralids'],
                               aulimit='max',
                               continuation=True):
         for user in result['query']['allusers']:
             ids.append(user['centralids']['CentralAuth'])
     return ids
 
 
 def full_url(endpoint: str, **kwargs) -> str:
     scheme = flask.request.headers.get('X-Forwarded-Proto', 'http')
     return flask.url_for(endpoint, _external=True, _scheme=scheme, **kwargs)
 
 @app.template_global()
 def current_url(external: bool = False) -> str:
     all_args = {}
     for args in [flask.request.args, flask.request.view_args]:
         all_args.update(args)
     # in Python 3.5+, replace that with **flask.request.args, **flask.request.view_args
 
     if external:
         return flask.url_for(flask.request.endpoint,
                              _external=True,
                              _scheme=flask.request.headers.get('X-Forwarded-Proto', 'http'),
                              **all_args)
     else:
         return flask.url_for(flask.request.endpoint,
                              **all_args)
 
 def submitted_request_valid() -> bool:
     """Check whether a submitted POST request is valid.
 
     If this method returns False, the request might have been issued
     by an attacker as part of a Cross-Site Request Forgery attack;
     callers MUST NOT process the request in that case.
     """
     real_token = flask.session.pop('csrf_token', None)
     log('CSRF', 'invalidated token from session')
     submitted_token = flask.request.form.get('csrf_token', None)
     if not real_token:
         # we never expected a POST
         log('CSRF', 'no real token')
         return False
     if not submitted_token:
         # token got lost or attacker did not supply it
         log('CSRF', 'no submitted token')
         return False
     if submitted_token != real_token:
         # incorrect token (could be outdated or incorrectly forged)
         log('CSRF', 'token mismatch')
         return False
     if not (flask.request.referrer or '').startswith(full_url('index')):
         # correct token but not coming from the correct page; for
         # example, JS running on https://tools.wmflabs.org/tool-a is
         # allowed to access https://tools.wmflabs.org/tool-b and
         # extract CSRF tokens from it (since both of these pages are
         # hosted on the https://tools.wmflabs.org domain), so checking
         # the Referer header is our only protection against attackers
         # from other Toolforge tools
         log('CSRF', 'referrer mismatch: should start with %s, got %s' % (full_url('index'), flask.request.referrer))
         return False
     return True
 
 @app.after_request
 def deny_frame(response: flask.Response) -> flask.Response:
     """Disallow embedding the tool’s pages in other websites.
 
     If other websites can embed this tool’s pages, e. g. in <iframe>s,
     other tools hosted on tools.wmflabs.org can send arbitrary web
     requests from this tool’s context, bypassing the referrer-based
     CSRF protection.
     """
     response.headers['X-Frame-Options'] = 'deny'
     return response
diff --git a/command.py b/command.py
index b838104..e58058f 100644
--- a/command.py
+++ b/command.py
@@ -1,355 +1,384 @@
 import datetime
 from typing import Any, List, Optional, Tuple, Union
 
 from action import Action
 from siteinfo import CategoryInfo
 
 
 class Command:
     """A list of actions to perform on a page."""
 
     def __init__(self, page: str, actions: List['Action']):
         self.page = page
         self.actions = actions
 
     def apply(self, wikitext: str, category_info: CategoryInfo) -> Tuple[str, List[Tuple[Action, bool]]]:
         """Apply the actions of this command to the given wikitext and return
         the result as well as the actions together with the
         information whether they were a no-op or not.
         """
         actions = []
 
         for action in self.actions:
             new_wikitext = action.apply(wikitext, category_info)
             actions.append((action, wikitext == new_wikitext))
             wikitext = new_wikitext
 
         return wikitext, actions
 
     def cleanup(self) -> None:
         """Partially normalize the command, as a convenience for users.
 
         This should not be used as a replacement for full
         normalization via the MediaWiki API.
         """
         self.page = self.page.replace('_', ' ')
         for action in self.actions:
             action.cleanup()
 
     def actions_tpsv(self) -> str:
         return '|'.join([str(action) for action in self.actions])
 
     def __eq__(self, value: Any) -> bool:
         return type(value) is Command and \
             self.page == value.page and \
             self.actions == value.actions
 
     def __str__(self) -> str:
         return self.page + '|' + self.actions_tpsv()
 
     def __repr__(self) -> str:
         return 'Command(' + repr(self.page) + ', ' + repr(self.actions) + ')'
 
 
 class CommandRecord:
     """A command that was recorded in some store."""
 
     def __init__(self, id: int, command: Command):
         self.id = id
         self.command = command
 
 
 class CommandPlan(CommandRecord):
     """A command that should be run in the future."""
 
     def __eq__(self, value: Any) -> bool:
         return type(value) is CommandPlan and \
             self.id == value.id and \
             self.command == value.command
 
     def __str__(self) -> str:
         return str(self.command)
 
     def __repr__(self) -> str:
         return 'CommandPlan(' + repr(self.id) + ', ' + repr(self.command) + ')'
 
 
 class CommandPending(CommandRecord):
     """A command that is about to be run or currently running."""
 
     def __eq__(self, value: Any) -> bool:
         return type(value) is CommandPending and \
             self.id == value.id and \
             self.command == value.command
 
     def __str__(self) -> str:
         return str(self.command)
 
     def __repr__(self) -> str:
         return 'CommandPending(' + repr(self.id) + ', ' + repr(self.command) + ')'
 
 
 class CommandFinish(CommandRecord):
     """A command that was intended to be run at some point
     and should now no longer be run."""
 
     def __str__(self) -> str:
         return '# ' + str(self.command)
 
 
 class CommandSuccess(CommandFinish):
     """A command that was successfully run."""
 
 
 class CommandEdit(CommandSuccess):
     """A command that resulted in an edit on a page."""
 
     def __init__(self, id: int, command: Command, base_revision: int, revision: int):
         assert base_revision < revision
         super().__init__(id, command)
         self.base_revision = base_revision
         self.revision = revision
 
     def __eq__(self, value: Any) -> bool:
         return type(value) is CommandEdit and \
             self.id == value.id and \
             self.command == value.command and \
             self.base_revision == value.base_revision and \
             self.revision == value.revision
 
     def __repr__(self) -> str:
         return 'CommandEdit(' + \
             repr(self.id) + ', ' + \
             repr(self.command) + ', ' + \
             repr(self.base_revision) + ', ' + \
             repr(self.revision) + ')'
 
 
 class CommandNoop(CommandSuccess):
     """A command that resulted in no change to a page."""
 
     def __init__(self, id: int, command: Command, revision: int):
         super().__init__(id, command)
         self.revision = revision
 
     def __eq__(self, value: Any) -> bool:
         return type(value) is CommandNoop and \
             self.id == value.id and \
             self.command == value.command and \
             self.revision == value.revision
 
     def __repr__(self) -> str:
         return 'CommandNoop(' + \
             repr(self.id) + ', ' + \
             repr(self.command) + ', ' + \
             repr(self.revision) + ')'
 
 
 class CommandFailure(CommandFinish):
     """A command that was not successfully run."""
 
     def can_retry_immediately(self) -> bool:
         """Whether it is okay to retry running this command immediately.
 
         In case of an immediate retry, no permanent record of the failure is kept,
         so this should not be used if the failure resulted in any actions on the wiki."""
         ...
 
     def can_retry_later(self) -> bool:
         """Whether it is okay to retry running this command at a later time.
 
         If True, a new command plan for the same command with a fresh ID
         will be appended to the end of the batch."""
         ...
 
     def can_continue_batch(self) -> Union[bool, datetime.datetime]:
         """Whether it is okay to continue with other commands in this batch.
 
         If the failure only affects this command, we can proceed with the batch as usual;
         if other commands are likely to fail for the same reason,
         or we should back off for some other reason,
         the batch should be suspended for a time.
 
         True means that we can continue immediately;
         False means that we should suspend the batch for an unspecified time
         (i. e., stop background runs and only proceed on manual input by the user);
         a datetime means that we should suspend the batch until that time
         (i. e., suspend background runs but resume them automatically)."""
         ...
 
 
 class CommandPageMissing(CommandFailure):
     """A command that failed because the specified page was found to be missing at the time."""
 
     def __init__(self, id: int, command: Command, curtimestamp: str):
         super().__init__(id, command)
         self.curtimestamp = curtimestamp
 
     def can_retry_immediately(self) -> bool:
         return False
 
     def can_retry_later(self) -> bool:
         return False
 
     def can_continue_batch(self) -> bool:
         return True
 
     def __eq__(self, value: Any) -> bool:
         return type(value) is CommandPageMissing and \
             self.id == value.id and \
             self.command == value.command and \
             self.curtimestamp == value.curtimestamp
 
     def __repr__(self) -> str:
         return 'CommandPageMissing(' + \
             repr(self.id) + ', ' + \
             repr(self.command) + ', ' + \
             repr(self.curtimestamp) + ')'
 
 
+class CommandTitleInvalid(CommandFailure):
+    """A command that failed because the specified title was invalid."""
+
+    def __init__(self, id: int, command: Command, curtimestamp: str):
+        super().__init__(id, command)
+        self.curtimestamp = curtimestamp
+
+    def can_retry_immediately(self) -> bool:
+        return False
+
+    def can_retry_later(self) -> bool:
+        return False
+
+    def can_continue_batch(self) -> bool:
+        return True
+
+    def __eq__(self, value: Any) -> bool:
+        return type(value) is CommandTitleInvalid and \
+            self.id == value.id and \
+            self.command == value.command and \
+            self.curtimestamp == value.curtimestamp
+
+    def __repr__(self) -> str:
+        return 'CommandTitleInvalid(' + \
+            repr(self.id) + ', ' + \
+            repr(self.command) + ', ' + \
+            repr(self.curtimestamp) + ')'
+
+
 class CommandPageProtected(CommandFailure):
     """A command that failed because the specified page was protected at the time."""
 
     def __init__(self, id: int, command: Command, curtimestamp: str):
         super().__init__(id, command)
         self.curtimestamp = curtimestamp
 
     def can_retry_immediately(self) -> bool:
         return False
 
     def can_retry_later(self) -> bool:
         return False
 
     def can_continue_batch(self) -> bool:
         return True
 
     def __eq__(self, value: Any) -> bool:
         return type(value) is CommandPageProtected and \
             self.id == value.id and \
             self.command == value.command and \
             self.curtimestamp == value.curtimestamp
 
     def __repr__(self) -> str:
         return 'CommandPageProtected(' + \
             repr(self.id) + ', ' + \
             repr(self.command) + ', ' + \
             repr(self.curtimestamp) + ')'
 
 
 class CommandEditConflict(CommandFailure):
     """A command that failed due to an edit conflict."""
 
     def can_retry_immediately(self) -> bool:
         return True
 
     def can_retry_later(self) -> bool:
         return True
 
     def can_continue_batch(self) -> bool:
         return True
 
     def __eq__(self, value: Any) -> bool:
         return type(value) is CommandEditConflict and \
             self.id == value.id and \
             self.command == value.command
 
     def __repr__(self) -> str:
         return 'CommandEditConflict(' + \
             repr(self.id) + ', ' + \
             repr(self.command) + ')'
 
 
 class CommandMaxlagExceeded(CommandFailure):
     """A command that failed replication lag in the database cluster was too high."""
 
     def __init__(self, id: int, command: Command, retry_after: datetime.datetime):
         super().__init__(id, command)
         self.retry_after = retry_after
 
     def can_retry_immediately(self) -> bool:
         return False
 
     def can_retry_later(self) -> bool:
         return True
 
     def can_continue_batch(self) -> datetime.datetime:
         return self.retry_after
 
     def __eq__(self, value: Any) -> bool:
         return type(value) is CommandMaxlagExceeded and \
             self.id == value.id and \
             self.command == value.command and \
             self.retry_after == value.retry_after
 
     def __repr__(self) -> str:
         return 'CommandMaxlagExceeded(' + \
             repr(self.id) + ', ' + \
             repr(self.command) + ', ' + \
             repr(self.retry_after) + ')'
 
 
 class CommandBlocked(CommandFailure):
     """A command that failed because the user or IP address was blocked."""
 
     def __init__(self, id: int, command: Command, auto: bool, blockinfo: Optional[dict]):
         super().__init__(id, command)
         self.auto = auto
         self.blockinfo = blockinfo
 
     def can_retry_immediately(self) -> bool:
         return False
 
     def can_retry_later(self) -> bool:
         return True
 
     def can_continue_batch(self) -> bool:
         # we could perhaps continue the batch if the block is partial
         # (that is, if self.blockinfo['blockpartial'] is True),
         # but for now I’d rather not
         return False
 
     def __eq__(self, value: Any) -> bool:
         return type(value) is CommandBlocked and \
             self.id == value.id and \
             self.command == value.command and \
             self.auto == value.auto and \
             self.blockinfo == value.blockinfo
 
     def __repr__(self) -> str:
         return 'CommandBlocked(' + \
             repr(self.id) + ', ' + \
             repr(self.command) + ', ' + \
             'auto=' + repr(self.auto) + ', ' + \
             'blockinfo=' + repr(self.blockinfo) + ')'
 
 
 class CommandWikiReadOnly(CommandFailure):
     """A command that failed because the wiki was in read-only mode."""
 
     def __init__(self, id: int, command: Command, reason: Optional[str], retry_after: Optional[datetime.datetime]):
         super().__init__(id, command)
         self.reason = reason
         self.retry_after = retry_after
 
     def can_retry_immediately(self) -> bool:
         return False
 
     def can_retry_later(self) -> bool:
         return True
 
     def can_continue_batch(self) -> Union[bool, datetime.datetime]:
         return self.retry_after or False
 
     def __eq__(self, value: Any) -> bool:
         return type(value) is CommandWikiReadOnly and \
             self.id == value.id and \
             self.command == value.command and \
             self.reason == value.reason and \
             self.retry_after == value.retry_after
 
     def __repr__(self) -> str:
         return 'CommandWikiReadOnly(' + \
             repr(self.id) + ', ' + \
             repr(self.command) + ', ' + \
             repr(self.reason) + ', ' + \
             repr(self.retry_after) + ')'
diff --git a/database.py b/database.py
index a9be04c..f36756f 100644
--- a/database.py
+++ b/database.py
@@ -1,609 +1,619 @@
 import contextlib
 import datetime
 import itertools
 import json
 import mwapi # type: ignore
 import mwoauth # type: ignore
 import pymysql
 import requests_oauthlib # type: ignore
 from typing import Any, Dict, Generator, List, Optional, Sequence, Tuple, Type
 
 from batch import NewBatch, StoredBatch, OpenBatch, ClosedBatch, BatchCommandRecords, BatchBackgroundRuns
-from command import Command, CommandPlan, CommandPending, CommandRecord, CommandFinish, CommandEdit, CommandNoop, CommandFailure, CommandPageMissing, CommandPageProtected, CommandEditConflict, CommandMaxlagExceeded, CommandBlocked, CommandWikiReadOnly
+from command import Command, CommandPlan, CommandPending, CommandRecord, CommandFinish, CommandEdit, CommandNoop, CommandFailure, CommandPageMissing, CommandTitleInvalid, CommandPageProtected, CommandEditConflict, CommandMaxlagExceeded, CommandBlocked, CommandWikiReadOnly
 from localuser import LocalUser
 import parse_tpsv
 from store import BatchStore, _local_user_from_session
 from stringstore import StringTableStore
 from timestamp import now, datetime_to_utc_timestamp, utc_timestamp_to_datetime
 
 
 class DatabaseStore(BatchStore):
 
     _BATCH_STATUS_OPEN = 0
     _BATCH_STATUS_CLOSED = 128
 
     _COMMAND_STATUS_PLAN = 0
     _COMMAND_STATUS_EDIT = 1
     _COMMAND_STATUS_NOOP = 2
     _COMMAND_STATUS_PENDING = 16
     _COMMAND_STATUS_PAGE_MISSING = 129
     _COMMAND_STATUS_EDIT_CONFLICT = 130
     _COMMAND_STATUS_MAXLAG_EXCEEDED = 131
     _COMMAND_STATUS_BLOCKED = 132
     _COMMAND_STATUS_WIKI_READ_ONLY = 133
     _COMMAND_STATUS_PAGE_PROTECTED = 134
+    _COMMAND_STATUS_TITLE_INVALID = 135
 
     def __init__(self, connection_params: dict):
         connection_params.setdefault('charset', 'utf8mb4')
         self.connection_params = connection_params
         self.domain_store = StringTableStore('domain', 'domain_id', 'domain_hash', 'domain_name')
         self.title_store = StringTableStore('title', 'title_id', 'title_hash', 'title_text')
         self.actions_store = StringTableStore('actions', 'actions_id', 'actions_hash', 'actions_tpsv')
         self.local_user_store = _LocalUserStore(self.domain_store)
 
     @contextlib.contextmanager
     def connect(self) -> Generator[pymysql.connections.Connection, None, None]:
         connection = pymysql.connect(**self.connection_params)
         try:
             yield connection
         finally:
             connection.close()
 
     def store_batch(self, new_batch: NewBatch, session: mwapi.Session) -> OpenBatch:
         created = now()
         created_utc_timestamp = datetime_to_utc_timestamp(created)
         local_user = _local_user_from_session(session)
 
         with self.connect() as connection:
             domain_id = self.domain_store.acquire_id(connection, local_user.domain)
             if new_batch.title:
                 title_id = self.title_store.acquire_id(connection, new_batch.title)
             else:
                 title_id = None
             localuser_id = self.local_user_store.acquire_localuser_id(connection, local_user)
             with connection.cursor() as cursor:
                 cursor.execute('INSERT INTO `batch` (`batch_localuser_id`, `batch_domain_id`, `batch_title`, `batch_created_utc_timestamp`, `batch_last_updated_utc_timestamp`, `batch_status`) VALUES (%s, %s, %s, %s, %s, %s)',
                                (localuser_id, domain_id, title_id, created_utc_timestamp, created_utc_timestamp, DatabaseStore._BATCH_STATUS_OPEN))
                 batch_id = cursor.lastrowid
 
             with connection.cursor() as cursor:
                 cursor.executemany('INSERT INTO `command` (`command_batch`, `command_page`, `command_actions_id`, `command_status`, `command_outcome`) VALUES (%s, %s, %s, %s, NULL)',
                                    [(batch_id, command.page, self.actions_store.acquire_id(connection, command.actions_tpsv()), DatabaseStore._COMMAND_STATUS_PLAN) for command in new_batch.commands])
 
             connection.commit()
 
         return OpenBatch(batch_id,
                          local_user,
                          local_user.domain,
                          new_batch.title,
                          created,
                          created,
                          _BatchCommandRecordsDatabase(batch_id, self),
                          _BatchBackgroundRunsDatabase(batch_id, local_user.domain, self))
 
     def get_batch(self, id: int) -> Optional[StoredBatch]:
         with self.connect() as connection:
             with connection.cursor() as cursor:
                 cursor.execute('''SELECT `batch_id`, `localuser_user_name`, `localuser_local_user_id`, `localuser_global_user_id`, `domain_name`, `title_text`, `batch_created_utc_timestamp`, `batch_last_updated_utc_timestamp`, `batch_status`
                                   FROM `batch`
                                   JOIN `domain` ON `batch_domain_id` = `domain_id`
                                   JOIN `localuser` ON `batch_localuser_id` = `localuser_id`
                                   LEFT JOIN `title` ON `batch_title` = `title_id`
                                   WHERE `batch_id` = %s''', (id,))
                 result = cursor.fetchone()
         if not result:
             return None
         return self._result_to_batch(result)
 
     def _result_to_batch(self, result: tuple) -> StoredBatch:
         id, user_name, local_user_id, global_user_id, domain, title, created_utc_timestamp, last_updated_utc_timestamp, status = result
         created = utc_timestamp_to_datetime(created_utc_timestamp)
         last_updated = utc_timestamp_to_datetime(last_updated_utc_timestamp)
         local_user = LocalUser(user_name, domain, local_user_id, global_user_id)
         if status == DatabaseStore._BATCH_STATUS_OPEN:
             return OpenBatch(id,
                              local_user,
                              local_user.domain,
                              title,
                              created,
                              last_updated,
                              _BatchCommandRecordsDatabase(id, self),
                              _BatchBackgroundRunsDatabase(id, local_user.domain, self))
         elif status == DatabaseStore._BATCH_STATUS_CLOSED:
             return ClosedBatch(id,
                                local_user,
                                local_user.domain,
                                title,
                                created,
                                last_updated,
                                _BatchCommandRecordsDatabase(id, self),
                                _BatchBackgroundRunsDatabase(id, local_user.domain, self))
         else:
             raise ValueError('Unknown batch type')
 
     def get_batches_slice(self, offset: int, limit: int) -> Sequence[StoredBatch]:
         with self.connect() as connection:
             with connection.cursor() as cursor:
                 cursor.execute('''SELECT `batch_id`, `localuser_user_name`, `localuser_local_user_id`, `localuser_global_user_id`, `domain_name`, `title_text`, `batch_created_utc_timestamp`, `batch_last_updated_utc_timestamp`, `batch_status`
                                   FROM `batch`
                                   JOIN `domain` ON `batch_domain_id` = `domain_id`
                                   JOIN `localuser` ON `batch_localuser_id` = `localuser_id`
                                   LEFT JOIN `title` ON `batch_title` = `title_id`
                                   ORDER BY `batch_id` DESC
                                   LIMIT %s
                                   OFFSET %s''',
                                (limit, offset))
                 return [self._result_to_batch(result) for result in cursor.fetchall()]
 
     def get_batches_count(self) -> int:
         with self.connect() as connection:
             with connection.cursor() as cursor:
                 cursor.execute('''SELECT COUNT(*) AS `count`
                                   FROM `batch`''')
                 (count,) = cursor.fetchone()
         return count
 
     def start_background(self, batch: OpenBatch, session: mwapi.Session) -> None:
         started = now()
         started_utc_timestamp = datetime_to_utc_timestamp(started)
         local_user = _local_user_from_session(session)
 
         with self.connect() as connection:
             with connection.cursor() as cursor:
                 cursor.execute('''SELECT 1
                                   FROM `background`
                                   WHERE `background_batch` = %s
                                   AND `background_stopped_utc_timestamp` IS NULL
                                   FOR UPDATE''',
                                (batch.id,))
                 if cursor.fetchone():
                     connection.commit() # finish the FOR UPDATE
                     return
 
             assert isinstance(session.session.auth, requests_oauthlib.OAuth1)
             auth = {'resource_owner_key': session.session.auth.client.resource_owner_key,
                     'resource_owner_secret': session.session.auth.client.resource_owner_secret}
 
             localuser_id = self.local_user_store.acquire_localuser_id(connection, local_user)
 
             with connection.cursor() as cursor:
                 cursor.execute('''INSERT INTO `background`
                                   (`background_batch`, `background_auth`, `background_started_utc_timestamp`, `background_started_localuser_id`)
                                   VALUES (%s, %s, %s, %s)''',
                                (batch.id, json.dumps(auth), started_utc_timestamp, localuser_id))
             connection.commit()
 
     def stop_background(self, batch: StoredBatch, session: Optional[mwapi.Session] = None) -> None:
         self._stop_background_by_id(batch.id, session)
 
     def _stop_background_by_id(self, batch_id: int, session: Optional[mwapi.Session] = None) -> None:
         stopped = now()
         stopped_utc_timestamp = datetime_to_utc_timestamp(stopped)
         with self.connect() as connection:
             if session:
                 local_user = _local_user_from_session(session)
                 localuser_id = self.local_user_store.acquire_localuser_id(connection, local_user) # type: Optional[int]
             else:
                 localuser_id = None
             with connection.cursor() as cursor:
                 cursor.execute('''UPDATE `background`
                                   SET `background_auth` = NULL, `background_stopped_utc_timestamp` = %s, `background_stopped_localuser_id` = %s, `background_suspended_until_utc_timestamp` = NULL
                                   WHERE `background_batch` = %s
                                   AND `background_stopped_utc_timestamp` IS NULL''',
                                (stopped_utc_timestamp, localuser_id, batch_id))
             connection.commit()
             if cursor.rowcount > 1:
                 raise RuntimeError('Should have stopped at most 1 background operation, actually affected %d!' % cursor.rowcount)
 
     def suspend_background(self, batch: StoredBatch, until: datetime.datetime) -> None:
         until_utc_timestamp = datetime_to_utc_timestamp(until)
         with self.connect() as connection, connection.cursor() as cursor:
             cursor.execute('''UPDATE `background`
                               SET `background_suspended_until_utc_timestamp` = %s
                               WHERE `background_batch` = %s
                               AND `background_stopped_utc_timestamp` IS NULL''',
                            (until_utc_timestamp, batch.id))
             connection.commit()
             if cursor.rowcount > 1:
                 raise RuntimeError('Should have suspended at most 1 background run, actually affected %d!' % cursor.rowcount)
 
     def make_plan_pending_background(self, consumer_token: mwoauth.ConsumerToken, user_agent: str) -> Optional[Tuple[OpenBatch, CommandPending, mwapi.Session]]:
         with self.connect() as connection:
             with connection.cursor() as cursor:
                 now_utc_timestamp = datetime_to_utc_timestamp(now())
                 cursor.execute('''SELECT `batch_id`, `localuser_user_name`, `localuser_local_user_id`, `localuser_global_user_id`, `domain_name`, `title_text`, `batch_created_utc_timestamp`, `batch_last_updated_utc_timestamp`, `batch_status`, `background_auth`, `command_id`, `command_page`, `actions_tpsv`
                                   FROM `background`
                                   JOIN `batch` ON `background_batch` = `batch_id`
                                   JOIN `command` ON `command_batch` = `batch_id`
                                   JOIN `domain` ON `batch_domain_id` = `domain_id`
                                   JOIN `actions` ON `command_actions_id` = `actions_id`
                                   JOIN `localuser` ON `batch_localuser_id` = `localuser_id`
                                   LEFT JOIN `title` ON `batch_title` = `title_id`
                                   WHERE `background_stopped_utc_timestamp` IS NULL
                                   AND COALESCE(`background_suspended_until_utc_timestamp`, 0) < %s
                                   AND `command_status` = %s
                                   ORDER BY `batch_last_updated_utc_timestamp` ASC, `command_id` ASC
                                   LIMIT 1
                                   FOR UPDATE''',
                                (now_utc_timestamp, DatabaseStore._COMMAND_STATUS_PLAN))
                 result = cursor.fetchone()
             if not result:
                 connection.commit() # finish the FOR UPDATE
                 return None
 
             with connection.cursor() as cursor:
                 cursor.execute('''UPDATE `command`
                                   SET `command_status` = %s
                                   WHERE `command_id` = %s AND `command_batch` = %s''',
                                (DatabaseStore._COMMAND_STATUS_PENDING, result[10], result[0]))
             connection.commit()
 
         auth_data = json.loads(result[9])
         auth = requests_oauthlib.OAuth1(client_key=consumer_token.key, client_secret=consumer_token.secret,
                                         resource_owner_key=auth_data['resource_owner_key'], resource_owner_secret=auth_data['resource_owner_secret'])
         session = mwapi.Session(host='https://'+result[4], auth=auth, user_agent=user_agent)
         command_pending = self._row_to_command_record(result[10],
                                                       result[11],
                                                       result[12],
                                                       DatabaseStore._COMMAND_STATUS_PENDING,
                                                       outcome=None)
         batch = self._result_to_batch(result[0:9])
 
         assert isinstance(batch, OpenBatch), "must be open since at least one command is still pending"
         assert isinstance(command_pending, CommandPending), "must be pending since we just set that status"
         return batch, command_pending, session
 
     def _command_finish_to_row(self, command_finish: CommandFinish) -> Tuple[int, dict]:
         if isinstance(command_finish, CommandEdit):
             status = DatabaseStore._COMMAND_STATUS_EDIT
             outcome = {'base_revision': command_finish.base_revision, 'revision': command_finish.revision} # type: dict
         elif isinstance(command_finish, CommandNoop):
             status = DatabaseStore._COMMAND_STATUS_NOOP
             outcome = {'revision': command_finish.revision}
         elif isinstance(command_finish, CommandPageMissing):
             status = DatabaseStore._COMMAND_STATUS_PAGE_MISSING
             outcome = {'curtimestamp': command_finish.curtimestamp}
+        elif isinstance(command_finish, CommandTitleInvalid):
+            status = DatabaseStore._COMMAND_STATUS_TITLE_INVALID
+            outcome = {'curtimestamp': command_finish.curtimestamp}
         elif isinstance(command_finish, CommandPageProtected):
             status = DatabaseStore._COMMAND_STATUS_PAGE_PROTECTED
             outcome = {'curtimestamp': command_finish.curtimestamp}
         elif isinstance(command_finish, CommandEditConflict):
             status = DatabaseStore._COMMAND_STATUS_EDIT_CONFLICT
             outcome = {}
         elif isinstance(command_finish, CommandMaxlagExceeded):
             status = DatabaseStore._COMMAND_STATUS_MAXLAG_EXCEEDED
             outcome = {'retry_after_utc_timestamp': datetime_to_utc_timestamp(command_finish.retry_after)}
         elif isinstance(command_finish, CommandBlocked):
             status = DatabaseStore._COMMAND_STATUS_BLOCKED
             outcome = {'auto': command_finish.auto, 'blockinfo': command_finish.blockinfo}
         elif isinstance(command_finish, CommandWikiReadOnly):
             status = DatabaseStore._COMMAND_STATUS_WIKI_READ_ONLY
             outcome = {'reason': command_finish.reason}
             if command_finish.retry_after:
                 outcome['retry_after_utc_timestamp'] = datetime_to_utc_timestamp(command_finish.retry_after)
         else:
             raise ValueError('Unknown command type')
 
         return status, outcome
 
     def _row_to_command_record(self, id: int, page: str, actions_tpsv: str, status: int, outcome: Optional[str]) -> CommandRecord:
         if outcome:
             outcome_dict = json.loads(outcome)
 
         command = Command(page,
                           [parse_tpsv.parse_action(field) for field in actions_tpsv.split('|')])
 
         if status == DatabaseStore._COMMAND_STATUS_PLAN:
             assert outcome is None
             return CommandPlan(id, command)
         elif status == DatabaseStore._COMMAND_STATUS_EDIT:
             return CommandEdit(id,
                                command,
                                base_revision=outcome_dict['base_revision'],
                                revision=outcome_dict['revision'])
         elif status == DatabaseStore._COMMAND_STATUS_NOOP:
             return CommandNoop(id,
                                command,
                                revision=outcome_dict['revision'])
         elif status == DatabaseStore._COMMAND_STATUS_PENDING:
             assert outcome is None
             return CommandPending(id, command)
         elif status == DatabaseStore._COMMAND_STATUS_PAGE_MISSING:
             return CommandPageMissing(id,
                                       command,
                                       curtimestamp=outcome_dict['curtimestamp'])
+        elif status == DatabaseStore._COMMAND_STATUS_TITLE_INVALID:
+            return CommandTitleInvalid(id,
+                                       command,
+                                       curtimestamp=outcome_dict['curtimestamp'])
         elif status == DatabaseStore._COMMAND_STATUS_PAGE_PROTECTED:
             return CommandPageProtected(id,
                                         command,
                                         curtimestamp=outcome_dict['curtimestamp'])
         elif status == DatabaseStore._COMMAND_STATUS_EDIT_CONFLICT:
             return CommandEditConflict(id,
                                        command)
         elif status == DatabaseStore._COMMAND_STATUS_MAXLAG_EXCEEDED:
             return CommandMaxlagExceeded(id,
                                          command,
                                          utc_timestamp_to_datetime(outcome_dict['retry_after_utc_timestamp']))
         elif status == DatabaseStore._COMMAND_STATUS_BLOCKED:
             return CommandBlocked(id,
                                   command,
                                   auto=outcome_dict['auto'],
                                   blockinfo=outcome_dict['blockinfo'])
         elif status == DatabaseStore._COMMAND_STATUS_WIKI_READ_ONLY:
             if 'retry_after_utc_timestamp' in outcome_dict:
                 retry_after = utc_timestamp_to_datetime(outcome_dict['retry_after_utc_timestamp']) # type: Optional[datetime.datetime]
             else:
                 retry_after = None
             return CommandWikiReadOnly(id,
                                        command,
                                        outcome_dict['reason'],
                                        retry_after)
         else:
             raise ValueError('Unknown command status %d' % status)
 
     def _status_to_command_record_type(self, status: int) -> Type[CommandRecord]:
         if status == DatabaseStore._COMMAND_STATUS_PLAN:
             return CommandPlan
         elif status == DatabaseStore._COMMAND_STATUS_EDIT:
             return CommandEdit
         elif status == DatabaseStore._COMMAND_STATUS_NOOP:
             return CommandNoop
         elif status == DatabaseStore._COMMAND_STATUS_PENDING:
             return CommandPending
         elif status == DatabaseStore._COMMAND_STATUS_PAGE_MISSING:
             return CommandPageMissing
+        elif status == DatabaseStore._COMMAND_STATUS_TITLE_INVALID:
+            return CommandTitleInvalid
         elif status == DatabaseStore._COMMAND_STATUS_PAGE_PROTECTED:
             return CommandPageProtected
         elif status == DatabaseStore._COMMAND_STATUS_EDIT_CONFLICT:
             return CommandEditConflict
         elif status == DatabaseStore._COMMAND_STATUS_MAXLAG_EXCEEDED:
             return CommandMaxlagExceeded
         elif status == DatabaseStore._COMMAND_STATUS_BLOCKED:
             return CommandBlocked
         elif status == DatabaseStore._COMMAND_STATUS_WIKI_READ_ONLY:
             return CommandWikiReadOnly
         else:
             raise ValueError('Unknown command status %d' % status)
 
 
 class _BatchCommandRecordsDatabase(BatchCommandRecords):
 
     def __init__(self, batch_id: int, store: DatabaseStore):
         self.batch_id = batch_id
         self.store = store
 
     def get_slice(self, offset: int, limit: int) -> List[CommandRecord]:
         command_records = []
         with self.store.connect() as connection, connection.cursor() as cursor:
             cursor.execute('''SELECT `command_id`, `command_page`, `actions_tpsv`, `command_status`, `command_outcome`
                               FROM `command`
                               JOIN `actions` ON `command_actions_id` = `actions_id`
                               WHERE `command_batch` = %s
                               ORDER BY `command_id` ASC
                               LIMIT %s OFFSET %s''', (self.batch_id, limit, offset))
             for id, page, actions_tpsv, status, outcome in cursor.fetchall():
                 command_records.append(self.store._row_to_command_record(id, page, actions_tpsv, status, outcome))
         return command_records
 
     def get_summary(self) -> Dict[Type[CommandRecord], int]:
         with self.store.connect() as connection, connection.cursor() as cursor:
             cursor.execute('''SELECT `command_status`, COUNT(*) AS `count`
                               FROM `command`
                               WHERE `command_batch` = %s
                               GROUP BY `command_status`''',
                            (self.batch_id,))
             return {self.store._status_to_command_record_type(status): count for status, count in cursor.fetchall()}
 
     def __len__(self) -> int:
         with self.store.connect() as connection, connection.cursor() as cursor:
             cursor.execute('SELECT COUNT(*) FROM `command` WHERE `command_batch` = %s', (self.batch_id,))
             (count,) = cursor.fetchone()
         return count
 
     def make_plans_pending(self, offset: int, limit: int) -> List[CommandPending]:
         with self.store.connect() as connection:
             command_ids = [] # List[int]
 
             with connection.cursor() as cursor:
                 # the extra subquery layer below is necessary to work around a MySQL/MariaDB restriction;
                 # based on https://stackoverflow.com/a/24777566/1420237
                 cursor.execute('''SELECT `command_id`
                                   FROM `command`
                                   WHERE `command_id` IN ( SELECT * FROM (
                                     SELECT `command_id`
                                     FROM `command`
                                     WHERE `command_batch` = %s
                                     ORDER BY `command_id` ASC
                                     LIMIT %s OFFSET %s
                                   ) AS temporary_table)
                                   AND `command_status` = %s
                                   ORDER BY `command_id` ASC
                                   FOR UPDATE''', (self.batch_id, limit, offset, DatabaseStore._COMMAND_STATUS_PLAN))
                 for (command_id,) in cursor.fetchall():
                     command_ids.append(command_id)
 
             if not command_ids:
                 connection.commit() # finish the FOR UPDATE
                 return []
 
             with connection.cursor() as cursor:
                 cursor.executemany('''UPDATE `command`
                                       SET `command_status` = %s
                                       WHERE `command_id` = %s AND `command_batch` = %s''',
                                    zip(itertools.repeat(DatabaseStore._COMMAND_STATUS_PENDING),
                                        command_ids,
                                        itertools.repeat(self.batch_id)))
             connection.commit()
 
             command_records = []
             with connection.cursor() as cursor:
                 cursor.execute('''SELECT `command_id`, `command_page`, `actions_tpsv`, `command_status`, `command_outcome`
                                   FROM `command`
                                   JOIN `actions` ON `command_actions_id` = `actions_id`
                                   WHERE `command_id` IN (%s)''' % ', '.join(['%s'] * len(command_ids)),
                                command_ids)
             for id, page, actions_tpsv, status, outcome in cursor.fetchall():
                 assert status == DatabaseStore._COMMAND_STATUS_PENDING
                 assert outcome is None
                 command_record = self.store._row_to_command_record(id, page, actions_tpsv, status, outcome)
                 assert isinstance(command_record, CommandPending)
                 command_records.append(command_record)
         return command_records
 
     def make_pendings_planned(self, command_record_ids: List[int]) -> None:
         with self.store.connect() as connection, connection.cursor() as cursor:
             parameters = [DatabaseStore._COMMAND_STATUS_PLAN] # in Python 3.5+, replace that with [DS._C_S_PLAN, *c_r_ids, DS._C_S_PENDING]
             parameters.extend(command_record_ids)
             parameters.append(DatabaseStore._COMMAND_STATUS_PENDING)
             cursor.execute('''UPDATE `command`
                               SET `command_status` = %%s
                               WHERE `command_id` IN (%s)
                               AND `command_status` = %%s''' % ', '.join(['%s'] * len(command_record_ids)),
                            parameters)
             connection.commit()
 
     def store_finish(self, command_finish: CommandFinish) -> None:
         last_updated = now()
         last_updated_utc_timestamp = datetime_to_utc_timestamp(last_updated)
         status, outcome = self.store._command_finish_to_row(command_finish)
 
         with self.store.connect() as connection, connection.cursor() as cursor:
             cursor.execute('''UPDATE `command`
                               SET `command_status` = %s, `command_outcome` = %s
                               WHERE `command_id` = %s AND `command_batch` = %s''',
                            (status, json.dumps(outcome), command_finish.id, self.batch_id))
             cursor.execute('''UPDATE `batch`
                               SET `batch_last_updated_utc_timestamp` = %s
                               WHERE `batch_id` = %s''', (last_updated_utc_timestamp, self.batch_id))
             connection.commit()
 
             if isinstance(command_finish, CommandFailure) and \
                command_finish.can_retry_later():
                 # append a fresh plan for the same command
                 cursor.execute('''INSERT INTO `command`
                                   (`command_batch`, `command_page`, `command_actions_id`, `command_status`, `command_outcome`)
                                   SELECT `command_batch`, `command_page`, `command_actions_id`, %s, NULL
                                   FROM `command`
                                   WHERE `command_id` = %s''',
                                (DatabaseStore._COMMAND_STATUS_PLAN, command_finish.id))
                 command_plan_id = cursor.lastrowid
                 cursor.execute('''INSERT INTO `retry`
                                   (`retry_failure`, `retry_new`)
                                   VALUES (%s, %s)''',
                                (command_finish.id, command_plan_id))
                 connection.commit()
             else:
                 # close the batch if no planned or pending commands are left in it
                 cursor.execute('''SELECT 1
                                   FROM `command`
                                   WHERE `command_batch` = %s
                                   AND `command_status` IN (%s, %s)
                                   LIMIT 1''',
                                (self.batch_id, DatabaseStore._COMMAND_STATUS_PLAN, DatabaseStore._COMMAND_STATUS_PENDING))
                 if not cursor.fetchone():
                     cursor.execute('''UPDATE `batch`
                                       SET `batch_status` = %s
                                       WHERE `batch_id` = %s''',
                                    (DatabaseStore._BATCH_STATUS_CLOSED, self.batch_id))
                     connection.commit()
                     self.store._stop_background_by_id(self.batch_id)
 
     def __eq__(self, value: Any) -> bool:
         # limited test to avoid overly expensive full comparison
         return type(value) is _BatchCommandRecordsDatabase and \
             self.batch_id == value.batch_id
 
 
 class _BatchBackgroundRunsDatabase(BatchBackgroundRuns):
 
     def __init__(self, batch_id: int, domain: str, store: DatabaseStore):
         self.batch_id = batch_id
         self.domain = domain
         self.store = store
 
     def currently_running(self) -> bool:
         with self.store.connect() as connection, connection.cursor() as cursor:
             cursor.execute('''SELECT 1
                               FROM `background`
                               WHERE `background_batch` = %s
                               AND `background_stopped_utc_timestamp` IS NULL
                               LIMIT 1''',
                            (self.batch_id,))
             return cursor.fetchone() is not None
 
     def _row_to_background_run(self,
                                started_utc_timestamp: int, started_user_name: str, started_local_user_id: int, started_global_user_id: int,
                                stopped_utc_timestamp: int, stopped_user_name: str, stopped_local_user_id: int, stopped_global_user_id: int) \
                                -> Tuple[Tuple[datetime.datetime, LocalUser], Optional[Tuple[datetime.datetime, Optional[LocalUser]]]]:
         background_start = (utc_timestamp_to_datetime(started_utc_timestamp), LocalUser(started_user_name, self.domain, started_local_user_id, started_global_user_id))
         if stopped_utc_timestamp:
             if stopped_user_name:
                 stopped_local_user = LocalUser(stopped_user_name, self.domain, stopped_local_user_id, stopped_global_user_id) # type: Optional[LocalUser]
             else:
                 stopped_local_user = None
             background_stop = (utc_timestamp_to_datetime(stopped_utc_timestamp), stopped_local_user) # type: Optional[Tuple[datetime.datetime, Optional[LocalUser]]]
         else:
             background_stop = None
         return (background_start, background_stop)
 
     def get_last(self) -> Optional[Tuple[Tuple[datetime.datetime, LocalUser], Optional[Tuple[datetime.datetime, Optional[LocalUser]]]]]:
         with self.store.connect() as connection, connection.cursor() as cursor:
             cursor.execute('''SELECT `background_started_utc_timestamp`, `started`.`localuser_user_name`, `started`.`localuser_local_user_id`, `started`.`localuser_global_user_id`, `background_stopped_utc_timestamp`, `stopped`.`localuser_user_name`, `stopped`.`localuser_local_user_id`, `stopped`.`localuser_global_user_id`
                               FROM `background`
                               JOIN `localuser` AS `started` ON `background_started_localuser_id` = `started`.`localuser_id`
                               LEFT JOIN `localuser` AS `stopped` ON `background_stopped_localuser_id` = `stopped`.`localuser_id`
                               WHERE `background_batch` = %s
                               ORDER BY `background_id` DESC
                               LIMIT 1''',
                            (self.batch_id,))
             result = cursor.fetchone()
             if result:
                 return self._row_to_background_run(*result)
             else:
                 return None
 
     def get_all(self) -> Sequence[Tuple[Tuple[datetime.datetime, LocalUser], Optional[Tuple[datetime.datetime, Optional[LocalUser]]]]]:
         with self.store.connect() as connection, connection.cursor() as cursor:
             cursor.execute('''SELECT `background_started_utc_timestamp`, `started`.`localuser_user_name`, `started`.`localuser_local_user_id`, `started`.`localuser_global_user_id`, `background_stopped_utc_timestamp`, `stopped`.`localuser_user_name`, `stopped`.`localuser_local_user_id`, `stopped`.`localuser_global_user_id`
                               FROM `background`
                               JOIN `localuser` AS `started` ON `background_started_localuser_id` = `started`.`localuser_id`
                               LEFT JOIN `localuser` AS `stopped` ON `background_stopped_localuser_id` = `stopped`.`localuser_id`
                               WHERE `background_batch` = %s
                               ORDER BY `background_id` ASC''',
                            (self.batch_id,))
             return [self._row_to_background_run(*row) for row in cursor.fetchall()]
 
     def __eq__(self, value: Any) -> bool:
         # limited test to avoid overly expensive full comparison
         return type(value) is _BatchBackgroundRunsDatabase and \
             self.batch_id == value.batch_id
 
 
 class _LocalUserStore:
     """Encapsulates access to a local user account in the localuser table.
 
        When a user has been renamed, the same ID will still be used
        and the name will be updated once the user is stored the next time."""
 
     def __init__(self, domain_store: StringTableStore):
         self.domain_store = domain_store
 
     def acquire_localuser_id(self, connection: pymysql.connections.Connection, local_user: LocalUser) -> int:
         domain_id = self.domain_store.acquire_id(connection, local_user.domain)
 
         with connection.cursor() as cursor:
             cursor.execute('''INSERT INTO `localuser`
                               (`localuser_user_name`, `localuser_domain_id`, `localuser_local_user_id`, `localuser_global_user_id`)
                               VALUES (%s, %s, %s, %s)
                               ON DUPLICATE KEY UPDATE `localuser_user_name` = %s''',
                            (local_user.user_name, domain_id, local_user.local_user_id, local_user.global_user_id,
                             local_user.user_name))
             localuser_id = cursor.lastrowid
             if not localuser_id: # not returned in the ON DUPLICATE KEY UPDATE case, apparently
                 cursor.execute('''SELECT `localuser_id`
                                   FROM `localuser`
                                   WHERE `localuser_local_user_id` = %s
                                   AND `localuser_domain_id` = %s''',
                                (local_user.local_user_id, domain_id))
                 (localuser_id,) = cursor.fetchone()
                 assert cursor.fetchone() is None
         connection.commit()
         return localuser_id
diff --git a/runner.py b/runner.py
index b71a757..da5dbda 100644
--- a/runner.py
+++ b/runner.py
@@ -1,142 +1,150 @@
 import datetime
 import mwapi # type: ignore
 from typing import Dict, List, Optional
 
-from command import CommandPending, CommandFinish, CommandEdit, CommandNoop, CommandPageMissing, CommandPageProtected, CommandEditConflict, CommandMaxlagExceeded, CommandBlocked, CommandWikiReadOnly
+from command import CommandPending, CommandFinish, CommandEdit, CommandNoop, CommandPageMissing, CommandTitleInvalid, CommandPageProtected, CommandEditConflict, CommandMaxlagExceeded, CommandBlocked, CommandWikiReadOnly
 import siteinfo
 
 
 class Runner():
 
     def __init__(self, session: mwapi.Session, summary_batch_title: Optional[str] = None, summary_batch_link: Optional[str] = None):
         self.session = session
         self.csrf_token = session.get(action='query',
                                       meta='tokens')['query']['tokens']['csrftoken']
         self.summary_batch_title = summary_batch_title
         self.summary_batch_link = summary_batch_link
         self.prepared_pages = {} # type: Dict[str, dict]
 
     def prepare_pages(self, titles: List[str]):
         assert titles
         assert len(titles) <= 50
 
         response = self.session.get(action='query',
                                     titles=titles,
                                     prop=['revisions'],
                                     rvprop=['ids', 'content', 'contentmodel', 'timestamp'],
                                     rvslots=['main'],
                                     curtimestamp=True,
                                     formatversion=2)
 
         for page in response['query']['pages']:
             title = page['title']
             if 'missing' in page:
                 self.prepared_pages[title] = {
                     'missing': True,
                     'curtimestamp': response['curtimestamp'],
                 }
                 continue
+            if 'invalid' in page:
+                self.prepared_pages[title] = {
+                    'invalid': True,
+                    'curtimestamp': response['curtimestamp'],
+                }
+                continue
             revision = page['revisions'][0]
             slot = revision['slots']['main']
             if slot['contentmodel'] != 'wikitext' or slot['contentformat'] != 'text/x-wiki':
                 raise ValueError('Unexpected content model or format for revision %d of page %s, refusing to edit!' % (revision['revid'], title))
             self.prepared_pages[title] = {
                 'wikitext': slot['content'],
                 'page_id': page['pageid'],
                 'base_timestamp': revision['timestamp'],
                 'base_revid': revision['revid'],
                 'start_timestamp': response['curtimestamp'],
             }
 
         for normalization in response['query'].get('normalized', {}):
             self.prepared_pages[normalization['from']] = self.prepared_pages[normalization['to']]
 
     def run_command(self, command_pending: CommandPending) -> CommandFinish:
         title = command_pending.command.page
         if title not in self.prepared_pages:
             self.prepare_pages([title])
         prepared_page = self.prepared_pages[title]
         category_info = siteinfo.category_info(self.session)
 
         if 'missing' in prepared_page:
             return CommandPageMissing(command_pending.id, command_pending.command, curtimestamp=prepared_page['curtimestamp'])
+        if 'invalid' in prepared_page:
+            return CommandTitleInvalid(command_pending.id, command_pending.command, curtimestamp=prepared_page['curtimestamp'])
 
         wikitext, actions = command_pending.command.apply(prepared_page['wikitext'], category_info)
         summary = ''
         major_commands, minor_commands = 0, 0
         for action, noop in actions:
             action_summary = action.summary(category_info)
             if noop:
                 action_summary = siteinfo.parentheses(self.session, action_summary)
             else:
                 if action.is_minor():
                     minor_commands += 1
                 else:
                     major_commands += 1
             if summary:
                 summary += siteinfo.comma_separator(self.session)
             summary += action_summary
 
         if self.summary_batch_title:
             summary += siteinfo.semicolon_separator(self.session)
             summary += self.summary_batch_title
             if self.summary_batch_link:
                 summary += siteinfo.word_separator(self.session)
                 summary += siteinfo.parentheses(self.session, self.summary_batch_link)
         elif self.summary_batch_link:
             summary += siteinfo.semicolon_separator(self.session)
             summary += self.summary_batch_link
 
         if wikitext == prepared_page['wikitext']:
             return CommandNoop(command_pending.id, command_pending.command, prepared_page['base_revid'])
         try:
             params = {'action': 'edit',
                       'pageid': prepared_page['page_id'],
                       'text': wikitext,
                       'summary': summary,
                       'bot': True,
                       'basetimestamp': prepared_page['base_timestamp'],
                       'starttimestamp': prepared_page['start_timestamp'],
                       'contentformat': 'text/x-wiki',
                       'contentmodel': 'wikitext',
                       'token': self.csrf_token,
                       'assert': 'user',
                       'maxlag': 5,
                       'formatversion': 2}
             if minor_commands < 2 and not major_commands:
                 params['minor'] = ''
             response = self.session.post(**params)
         except mwapi.errors.APIError as e:
             if e.code == 'editconflict':
                 del self.prepared_pages[title] # this must be outdated now
                 return CommandEditConflict(command_pending.id, command_pending.command)
             elif e.code == 'protectedpage':
                 return CommandPageProtected(command_pending.id, command_pending.command, curtimestamp=prepared_page['start_timestamp'])
             elif e.code == 'maxlag':
                 retry_after_seconds = 5 # the API returns this in a Retry-After header, but mwapi hides that from us :(
                 retry_after = datetime.datetime.now(datetime.timezone.utc) + datetime.timedelta(seconds=retry_after_seconds)
                 retry_after = retry_after.replace(microsecond=0)
                 return CommandMaxlagExceeded(command_pending.id, command_pending.command, retry_after)
             elif e.code == 'blocked' or e.code == 'autoblocked':
                 auto = e.code == 'autoblocked'
                 blockinfo = None # the API returns this in a 'blockinfo' member of the 'error' object, but mwapi hides that from us :(
                 return CommandBlocked(command_pending.id, command_pending.command, auto, blockinfo)
             elif e.code == 'readonly':
                 reason = None # the API returns this in a 'readonlyreason' member of the 'error' object, but mwapi hides that from us :(
                 # announced read-only times are usually scheduled for one hour,
                 # though the actual read-only time is often much shorter, only a few minutes;
                 # guess half an hour as a compromise
                 retry_after_minutes = 30
                 retry_after = datetime.datetime.now(datetime.timezone.utc) + datetime.timedelta(minutes=retry_after_minutes)
                 retry_after = retry_after.replace(microsecond=0)
                 return CommandWikiReadOnly(command_pending.id, command_pending.command, reason, retry_after)
             else:
                 raise e
 
         if 'nochange' in response['edit']:
             del self.prepared_pages[title] # this must be outdated now, otherwise we would’ve detected the no-op before trying to edit
             return CommandNoop(command_pending.id, command_pending.command, prepared_page['base_revid'])
 
         assert response['edit']['oldrevid'] == prepared_page['base_revid']
         del self.prepared_pages[title] # this must be outdated now, and we don’t know the new wikitext since non-conflicting edits may have been merged
         return CommandEdit(command_pending.id, command_pending.command, response['edit']['oldrevid'], response['edit']['newrevid'])
diff --git a/templates/command_title_invalid.html b/templates/command_title_invalid.html
new file mode 100644
index 0000000..0630d6a
--- /dev/null
+++ b/templates/command_title_invalid.html
@@ -0,0 +1,2 @@
+{% include "command_title_invalid_badge.html" %}
+{{ render_command(command_title_invalid.command, domain) }}
diff --git a/templates/command_title_invalid_badge.html b/templates/command_title_invalid_badge.html
new file mode 100644
index 0000000..a2cb536
--- /dev/null
+++ b/templates/command_title_invalid_badge.html
@@ -0,0 +1 @@
+<span class="badge badge-warning" title="the title was not a valid page title">title invalid</span>
diff --git a/test_command.py b/test_command.py
index bac5f8a..464645d 100644
--- a/test_command.py
+++ b/test_command.py
@@ -1,389 +1,429 @@
 import datetime
 import pytest # type: ignore
 
 from action import AddCategoryAction, RemoveCategoryAction
-from command import Command, CommandPlan, CommandPending, CommandEdit, CommandNoop, CommandPageMissing, CommandPageProtected, CommandEditConflict, CommandMaxlagExceeded, CommandBlocked, CommandWikiReadOnly
+from command import Command, CommandPlan, CommandPending, CommandEdit, CommandNoop, CommandPageMissing, CommandTitleInvalid, CommandPageProtected, CommandEditConflict, CommandMaxlagExceeded, CommandBlocked, CommandWikiReadOnly
 
 from test_action import addCategory1, removeCategory2, addCategory3
 
 
 command1 = Command('Page 1', [addCategory1, removeCategory2])
 command2 = Command('Page 2', [addCategory3])
 
 
 def test_Command_apply():
     wikitext = 'Test page for the QuickCategories tool.\n[[Category:Already present cat]]\n[[Category:Removed cat]]\nBottom text'
     command = Command('Page title', [AddCategoryAction('Added cat'),
                                      AddCategoryAction('Already present cat'),
                                      RemoveCategoryAction('Removed cat'),
                                      RemoveCategoryAction('Not present cat')])
     new_wikitext, actions = command.apply(wikitext, ('Category', ['Category'], 'first-letter'))
     assert new_wikitext == 'Test page for the QuickCategories tool.\n[[Category:Already present cat]]\n[[Category:Added cat]]\nBottom text'
     assert actions == [(command.actions[0], False),
                        (command.actions[1], True),
                        (command.actions[2], False),
                        (command.actions[3], True)]
 
 def test_Command_cleanup():
     command = Command('Page_from_URL', [AddCategoryAction('Category_from_URL')])
     command.cleanup()
     assert command == Command('Page from URL', [AddCategoryAction('Category from URL')])
 
 def test_Command_actions_tpsv():
     assert command1.actions_tpsv() == '+Category:Cat 1|-Category:Cat 2'
 
 def test_Command_eq_same():
     assert command1 == command1
 
 def test_Command_eq_equal():
     assert command1 == Command(command1.page, command1.actions)
 
 def test_Command_eq_different_type():
     assert command1 != addCategory1
 
 def test_Command_eq_different_page():
     assert command1 != Command('Page A', command1.actions)
     assert command1 != Command('Page_1', command1.actions)
 
 def test_Command_eq_different_actions():
     assert command1 != Command(command1.page, [addCategory1])
 
 def test_Command_str():
     assert str(command1) == 'Page 1|+Category:Cat 1|-Category:Cat 2'
 
 def test_Command_repr():
     assert eval(repr(command1)) == command1
 
 
 commandPlan1 = CommandPlan(42, command1)
 
 
 def test_CommandPlan_eq_same():
     assert commandPlan1 == commandPlan1
 
 def test_CommandPlan_eq_equal():
     assert commandPlan1 == CommandPlan(commandPlan1.id, commandPlan1.command)
 
 def test_CommandPlan_eq_different_type():
     assert commandPlan1 != commandPending1
 
 def test_CommandPlan_eq_different_id():
     assert commandPlan1 != CommandPlan(43, commandPlan1.command)
 
 def test_CommandPlan_eq_different_command():
     assert commandPlan1 != CommandPlan(commandPlan1.id, command2)
 
 def test_CommandPlan_str():
     assert str(commandPlan1) == str(command1)
 
 def test_CommandPlan_repr():
     assert eval(repr(commandPlan1)) == commandPlan1
 
 
 commandPending1 = CommandPending(42, command1)
 
 
 def test_CommandPending_eq_same():
     assert commandPending1 == commandPending1
 
 def test_CommandPending_eq_equal():
     assert commandPending1 == CommandPending(commandPending1.id, commandPending1.command)
 
 def test_CommandPending_eq_different_type():
     assert commandPending1 != commandPlan1
 
 def test_CommandPending_eq_different_id():
     assert commandPending1 != CommandPending(43, commandPending1.command)
 
 def test_CommandPending_eq_different_command():
     assert commandPending1 != CommandPending(commandPending1.id, command2)
 
 def test_CommandPending_str():
     assert str(commandPending1) == str(command1)
 
 def test_CommandPending_repr():
     assert eval(repr(commandPending1)) == commandPending1
 
 
 commandEdit1 = CommandEdit(42, command2, 1234, 1235)
 
 
 def test_CommandEdit_init():
     with pytest.raises(AssertionError):
         CommandEdit(42, command1, base_revision=1235, revision=1234)
 
 def test_CommandEdit_eq_same():
     assert commandEdit1 == commandEdit1
 
 def test_CommandEdit_eq_equal():
     assert commandEdit1 == CommandEdit(42, command2, 1234, 1235)
 
 def test_CommandEdit_eq_different_id():
     assert commandEdit1 != CommandEdit(43, commandEdit1.command, commandEdit1.base_revision, commandEdit1.revision)
 
 def test_CommandEdit_eq_different_command():
     assert commandEdit1 != CommandEdit(commandEdit1.id, command1, commandEdit1.base_revision, commandEdit1.revision)
 
 def test_CommandEdit_eq_different_base_revisoin():
     assert commandEdit1 != CommandEdit(commandEdit1.id, commandEdit1.command, 1233, commandEdit1.revision)
 
 def test_CommandEdit_eq_different_revision():
     assert commandEdit1 != CommandEdit(commandEdit1.id, commandEdit1.command, commandEdit1.base_revision, 1236)
 
 def test_CommandEdit_str():
     assert str(commandEdit1) == '# ' + str(command2)
 
 def test_CommandEdit_repr():
     assert eval(repr(commandEdit1)) == commandEdit1
 
 
 commandNoop1 = CommandNoop(42, command2, 1234)
 
 
 def test_CommandNoop_eq_same():
     assert commandNoop1 == commandNoop1
 
 def test_CommandNoop_eq_equal():
     assert commandNoop1 == CommandNoop(42, command2, 1234)
 
 def test_CommandNoop_eq_different_id():
     assert commandNoop1 != CommandNoop(43, commandNoop1.command, commandNoop1.revision)
 
 def test_CommandNoop_eq_different_command():
     assert commandNoop1 != CommandNoop(commandNoop1.id, command1, commandNoop1.revision)
 
 def test_CommandNoop_eq_different_revision():
     assert commandNoop1 != CommandNoop(commandNoop1.id, commandNoop1.command, 1235)
 
 def test_CommandNoop_str():
     assert str(commandNoop1) == '# ' + str(command2)
 
 def test_CommandNoop_repr():
     assert eval(repr(commandNoop1)) == commandNoop1
 
 
 commandWithMissingPage = Command('Page that definitely does not exist', command2.actions)
 commandPageMissing1 = CommandPageMissing(42, commandWithMissingPage, '2019-03-11T23:26:02Z')
 
 
 def test_CommandPageMissing_can_retry_immediately():
     assert not commandPageMissing1.can_retry_immediately()
 
 def test_CommandPageMissing_can_retry_later():
     assert not commandPageMissing1.can_retry_later()
 
 def test_CommandPageMissing_can_continue_batch():
     assert commandPageMissing1.can_continue_batch()
 
 def test_CommandPageMissing_eq_same():
     assert commandPageMissing1 == commandPageMissing1
 
 def test_CommandPageMissing_eq_equal():
     assert commandPageMissing1 == CommandPageMissing(42, commandWithMissingPage, '2019-03-11T23:26:02Z')
 
 def test_CommandPageMissing_eq_different_type():
     assert commandPageMissing1 != commandPageProtected1
+    assert commandPageMissing1 != commandTitleInvalid1
 
 def test_CommandPageMissing_eq_different_id():
     assert commandPageMissing1 != CommandPageMissing(43, commandPageMissing1.command, commandPageMissing1.curtimestamp)
 
 def test_CommandPageMissing_eq_different_command():
     assert commandPageMissing1 != CommandPageMissing(commandPageMissing1.id, command2, commandPageMissing1.curtimestamp)
 
 def test_CommandPageMissing_eq_different_curtimestamp():
     assert commandPageMissing1 != CommandPageMissing(commandPageMissing1.id, commandPageMissing1.command, '2019-03-11T23:28:12Z')
 
 def test_CommandPageMissing_str():
     assert str(commandPageMissing1) == '# ' + str(commandWithMissingPage)
 
 def test_CommandPageMissing_repr():
     assert eval(repr(commandPageMissing1)) == commandPageMissing1
 
 
+commandWithInvalidTitle = Command('Category:', command2.actions)
+commandTitleInvalid1 = CommandTitleInvalid(42, commandWithInvalidTitle, '2019-03-11T23:26:02Z')
+
+
+def test_CommandTitleInvalid_can_retry_immediately():
+    assert not commandTitleInvalid1.can_retry_immediately()
+
+def test_CommandTitleInvalid_can_retry_later():
+    assert not commandTitleInvalid1.can_retry_later()
+
+def test_CommandTitleInvalid_can_continue_batch():
+    assert commandTitleInvalid1.can_continue_batch()
+
+def test_CommandTitleInvalid_eq_same():
+    assert commandTitleInvalid1 == commandTitleInvalid1
+
+def test_CommandTitleInvalid_eq_equal():
+    assert commandTitleInvalid1 == CommandTitleInvalid(42, commandWithInvalidTitle, '2019-03-11T23:26:02Z')
+
+def test_CommandTitleInvalid_eq_different_type():
+    assert commandTitleInvalid1 != commandPageProtected1
+    assert commandTitleInvalid1 != commandPageMissing1
+
+def test_CommandTitleInvalid_eq_different_id():
+    assert commandTitleInvalid1 != CommandTitleInvalid(43, commandTitleInvalid1.command, commandTitleInvalid1.curtimestamp)
+
+def test_CommandTitleInvalid_eq_different_command():
+    assert commandTitleInvalid1 != CommandTitleInvalid(commandTitleInvalid1.id, command2, commandTitleInvalid1.curtimestamp)
+
+def test_CommandTitleInvalid_eq_different_curtimestamp():
+    assert commandTitleInvalid1 != CommandTitleInvalid(commandTitleInvalid1.id, commandTitleInvalid1.command, '2019-03-11T23:28:12Z')
+
+def test_CommandTitleInvalid_str():
+    assert str(commandTitleInvalid1) == '# ' + str(commandWithInvalidTitle)
+
+def test_CommandTitleInvalid_repr():
+    assert eval(repr(commandTitleInvalid1)) == commandTitleInvalid1
+
+
 commandWithProtectedPage = Command('Main Page', command2.actions)
 commandPageProtected1 = CommandPageProtected(42, commandWithProtectedPage, '2019-03-11T23:26:02Z')
 
 
 def test_CommandPageProtected_can_retry_immediately():
     assert not commandPageProtected1.can_retry_immediately()
 
 def test_CommandPageProtected_can_retry_later():
     assert not commandPageProtected1.can_retry_later()
 
 def test_CommandPageProtected_can_continue_batch():
     assert commandPageProtected1.can_continue_batch()
 
 def test_CommandPageProtected_eq_same():
     assert commandPageProtected1 == commandPageProtected1
 
 def test_CommandPageProtected_eq_equal():
     assert commandPageProtected1 == CommandPageProtected(42, commandWithProtectedPage, '2019-03-11T23:26:02Z')
 
 def test_CommandPageProtected_eq_different_type():
     assert commandPageProtected1 != commandPageMissing1
 
 def test_CommandPageProtected_eq_different_id():
     assert commandPageProtected1 != CommandPageProtected(43, commandPageProtected1.command, commandPageProtected1.curtimestamp)
 
 def test_CommandPageProtected_eq_different_command():
     assert commandPageProtected1 != CommandPageProtected(commandPageProtected1.id, command2, commandPageProtected1.curtimestamp)
 
 def test_CommandPageProtected_eq_different_curtimestamp():
     assert commandPageProtected1 != CommandPageProtected(commandPageProtected1.id, commandPageProtected1.command, '2019-03-11T23:28:12Z')
 
 def test_CommandPageProtected_str():
     assert str(commandPageProtected1) == '# ' + str(commandWithProtectedPage)
 
 def test_CommandPageProtected_repr():
     assert eval(repr(commandPageProtected1)) == commandPageProtected1
 
 
 commandEditConflict1 = CommandEditConflict(42, command1)
 
 
 def test_CommandEditConflict_can_retry_immediately():
     assert commandEditConflict1.can_retry_immediately()
 
 def test_CommandEditConflict_can_retry_later():
     assert commandEditConflict1.can_retry_later()
 
 def test_CommandEditConflict_can_continue_batch():
     assert commandEditConflict1.can_continue_batch()
 
 def test_CommandEditConflict_eq_same():
     assert commandEditConflict1 == commandEditConflict1
 
 def test_CommandEditConflict_eq_equal():
     assert commandEditConflict1 == CommandEditConflict(42, command1)
 
 def test_CommandEditConflict_eq_different_id():
     assert commandEditConflict1 != CommandEditConflict(43, commandEditConflict1.command)
 
 def test_CommandEditConflict_eq_different_command():
     assert commandEditConflict1 != CommandEditConflict(commandEditConflict1.id, command2)
 
 def test_CommandEditConflict_str():
     assert str(commandEditConflict1) == '# ' + str(command1)
 
 def test_CommandEditConflict_repr():
     assert eval(repr(commandEditConflict1)) == commandEditConflict1
 
 
 commandMaxlagExceeded1 = CommandMaxlagExceeded(42, command1, datetime.datetime(2019, 3, 16, 15, 24, 2, tzinfo=datetime.timezone.utc))
 
 
 def test_CommandMaxlagExceeded_can_retry_immediately():
     assert not commandMaxlagExceeded1.can_retry_immediately()
 
 def test_CommandMaxlagExceeded_can_retry_later():
     assert commandMaxlagExceeded1.can_retry_later()
 
 def test_CommandMaxlagExceeded_can_continue_batch():
     assert commandMaxlagExceeded1.can_continue_batch() == commandMaxlagExceeded1.retry_after
 
 def test_CommandMaxlagExceeded_eq_same():
     assert commandMaxlagExceeded1 == commandMaxlagExceeded1
 
 def test_CommandMaxlagExceeded_eq_equal():
     assert commandMaxlagExceeded1 == CommandMaxlagExceeded(42, command1, datetime.datetime(2019, 3, 16, 15, 24, 2, tzinfo=datetime.timezone.utc))
 
 def test_CommandMaxlagExceeded_eq_different_id():
     assert commandMaxlagExceeded1 != CommandMaxlagExceeded(43, commandMaxlagExceeded1.command, commandMaxlagExceeded1.retry_after)
 
 def test_CommandMaxlagExceeded_eq_different_command():
     assert commandMaxlagExceeded1 != CommandMaxlagExceeded(commandMaxlagExceeded1.id, command2, commandMaxlagExceeded1.retry_after)
 
 def test_CommandMaxlagExceeded_eq_different_retry_after():
     assert commandMaxlagExceeded1 != CommandMaxlagExceeded(commandMaxlagExceeded1.id, commandMaxlagExceeded1.command, datetime.datetime(2019, 3, 16, 15, 24, 2, tzinfo=datetime.timezone.max))
 
 def test_CommandMaxlagExceeded_str():
     assert str(commandMaxlagExceeded1) == '# ' + str(command1)
 
 def test_CommandMaxlagExceeded_repr():
     assert eval(repr(commandMaxlagExceeded1)) == commandMaxlagExceeded1
 
 
 blockinfo = {
     'blockedby': 'Lucas Werkmeister',
     'blockedbyid': 1,
     'blockedtimestamp': '2019-03-16T17:44:22Z',
     'blockexpiry': 'indefinite',
     'blockid': 1,
     'blockpartial': False,
     'blockreason': 'my custom reason',
 }
 commandBlocked1 = CommandBlocked(42, command1, False, blockinfo)
 commandBlocked2 = CommandBlocked(42, command1, False, None)
 
 
 def test_CommandBlocked_can_retry_immediately():
     assert not commandBlocked1.can_retry_immediately()
 
 def test_CommandBlocked_can_retry_later():
     assert commandBlocked1.can_retry_later()
 
 def test_CommandBlocked_can_continue_batch():
     assert not commandBlocked1.can_continue_batch()
 
 def test_CommandBlocked_eq_same():
     assert commandBlocked1 == commandBlocked1
 
 def test_CommandBlocked_eq_equal():
     assert commandBlocked1 == CommandBlocked(42, command1, False, blockinfo)
 
 def test_CommandBlocked_eq_different_id():
     assert commandBlocked1 != CommandBlocked(43, commandBlocked1.command, commandBlocked1.auto, commandBlocked1.blockinfo)
 
 def test_CommandBlocked_eq_different_command():
     assert commandBlocked1 != CommandBlocked(commandBlocked1.id, command2, commandBlocked1.auto, commandBlocked1.blockinfo)
 
 def test_CommandBlocked_eq_different_auto():
     assert commandBlocked1 != CommandBlocked(commandBlocked1.id, commandBlocked1.command, True, blockinfo)
 
 def test_CommandBlocked_eq_different_blockinfo():
     assert commandBlocked1 != CommandBlocked(commandBlocked1.id, commandBlocked1.command, commandBlocked1.auto, None)
 
 def test_CommandBlocked_str():
     assert str(commandBlocked1) == '# ' + str(command1)
 
 def test_CommandBlocked_repr():
     assert eval(repr(commandBlocked1)) == commandBlocked1
 
 
 commandWikiReadOnly1 = CommandWikiReadOnly(42, command1, 'maintenance', datetime.datetime(2019, 3, 16, 15, 24, 2, tzinfo=datetime.timezone.utc))
 commandWikiReadOnly2 = CommandWikiReadOnly(42, command1, None, None)
 
 
 def test_CommandWikiReadOnly_can_retry_immediately():
     assert not commandWikiReadOnly1.can_retry_immediately()
 
 def test_CommandWikiReadOnly_can_retry_later():
     assert commandWikiReadOnly1.can_retry_later()
 
 def test_CommandWikiReadOnly_can_continue_batch():
     assert commandWikiReadOnly1.can_continue_batch() == commandWikiReadOnly1.retry_after
     assert commandWikiReadOnly2.can_continue_batch() is False
 
 def test_CommandWikiReadOnly_eq_same():
     assert commandWikiReadOnly1 == commandWikiReadOnly1
 
 def test_CommandWikiReadOnly_eq_equal():
     assert commandWikiReadOnly1 == CommandWikiReadOnly(42, command1, 'maintenance', datetime.datetime(2019, 3, 16, 15, 24, 2, tzinfo=datetime.timezone.utc))
 
 def test_CommandWikiReadOnly_eq_different_id():
     assert commandWikiReadOnly1 != CommandWikiReadOnly(43, commandWikiReadOnly1.command, commandWikiReadOnly1.reason, commandWikiReadOnly1.retry_after)
 
 def test_CommandWikiReadOnly_eq_different_command():
     assert commandWikiReadOnly1 != CommandWikiReadOnly(commandWikiReadOnly1.id, command2, commandWikiReadOnly1.reason, commandWikiReadOnly1.retry_after)
 
 def test_CommandWikiReadOnly_eq_different_reason():
     assert commandWikiReadOnly1 != CommandWikiReadOnly(commandWikiReadOnly1.id, commandWikiReadOnly1.command, None, commandWikiReadOnly1.retry_after)
 
 def test_CommandWikiReadOnly_eq_different_retry_after():
     assert commandWikiReadOnly1 != CommandWikiReadOnly(commandWikiReadOnly1.id, commandWikiReadOnly1.command, commandWikiReadOnly1.reason, None)
 
 def test_CommandWikiReadOnly_str():
     assert str(commandWikiReadOnly1) == '# ' + str(command1)
 
 def test_CommandWikiReadOnly_repr():
     assert eval(repr(commandWikiReadOnly1)) == commandWikiReadOnly1
diff --git a/test_database.py b/test_database.py
index 358dedc..3960b9e 100644
--- a/test_database.py
+++ b/test_database.py
@@ -1,252 +1,253 @@
 import json
 import pymysql
 import pytest # type: ignore
 from typing import List, Optional, Tuple
 
 from command import CommandRecord, CommandEdit, CommandNoop
 from database import DatabaseStore, _LocalUserStore
 from localuser import LocalUser
 from stringstore import StringTableStore
 
 from test_batch import newBatch1
-from test_command import commandPlan1, commandPending1, commandEdit1, commandNoop1, commandPageMissing1, commandPageProtected1, commandEditConflict1, commandMaxlagExceeded1, commandBlocked1, blockinfo, commandBlocked2, commandWikiReadOnly1, commandWikiReadOnly2
+from test_command import commandPlan1, commandPending1, commandEdit1, commandNoop1, commandPageMissing1, commandTitleInvalid1, commandPageProtected1, commandEditConflict1, commandMaxlagExceeded1, commandBlocked1, blockinfo, commandBlocked2, commandWikiReadOnly1, commandWikiReadOnly2
 from test_localuser import localUser1, localUser2
 from test_utils import FakeSession
 
 
 fake_session = FakeSession({
     'query': {
         'userinfo': {
             'id': 6198807,
             'name': 'Lucas Werkmeister',
             'centralids': {
                 'CentralAuth': 46054761,
                 'local': 6198807
             },
             'attachedlocal': {
                 'CentralAuth': '',
                 'local': ''
             }
         }
     }
 })
 fake_session.host = 'https://commons.wikimedia.org'
 
 
 def test_DatabaseStore_store_batch(database_connection_params):
     store = DatabaseStore(database_connection_params)
     open_batch = store.store_batch(newBatch1, fake_session)
     command2 = open_batch.command_records.get_slice(1, 1)[0]
 
     with store.connect() as connection:
         with connection.cursor() as cursor:
             cursor.execute('SELECT `command_page`, `actions_tpsv` FROM `command` JOIN `actions` on `command_actions_id` = `actions_id` WHERE `command_id` = %s AND `command_batch` = %s', (command2.id, open_batch.id))
             command2_page, command2_actions_tpsv = cursor.fetchone()
             assert command2_page == command2.command.page
             assert command2_actions_tpsv == command2.command.actions_tpsv()
 
 def test_DatabaseStore_update_batch(database_connection_params, frozen_time):
     store = DatabaseStore(database_connection_params)
     stored_batch = store.store_batch(newBatch1, fake_session)
     loaded_batch = store.get_batch(stored_batch.id)
 
     [command_plan_1, command_plan_2] = loaded_batch.command_records.get_slice(0, 2)
 
     command_edit = CommandEdit(command_plan_1.id, command_plan_1.command, 1234, 1235)
     loaded_batch.command_records.store_finish(command_edit)
     command_edit_loaded = loaded_batch.command_records.get_slice(0, 1)[0]
     assert command_edit == command_edit_loaded
 
     command_noop = CommandNoop(command_plan_1.id, command_plan_1.command, 1234)
     frozen_time.tick() # make sure that this update increases last_updated
     loaded_batch.command_records.store_finish(command_noop)
     command_noop_loaded = loaded_batch.command_records.get_slice(0, 1)[0]
     assert command_noop == command_noop_loaded
 
     assert stored_batch.command_records.get_slice(0, 2) == loaded_batch.command_records.get_slice(0, 2)
 
     # TODO ideally, the timestamps on stored_batch and loaded_batch would update as well
     reloaded_batch = store.get_batch(stored_batch.id)
     assert reloaded_batch.last_updated > reloaded_batch.created
 
 def test_DatabaseStore_start_background_inserts_row(database_connection_params):
     store = DatabaseStore(database_connection_params)
     open_batch = store.store_batch(newBatch1, fake_session)
     store.start_background(open_batch, fake_session)
     with store.connect() as connection, connection.cursor() as cursor:
         cursor.execute('SELECT `localuser_user_name`, `background_auth` FROM `background` JOIN `localuser` ON `background_started_localuser_id` = `localuser_id`')
         assert cursor.rowcount == 1
         user_name, auth = cursor.fetchone()
         assert user_name == 'Lucas Werkmeister'
         assert json.loads(auth) == {'resource_owner_key': 'fake resource owner key',
                                     'resource_owner_secret': 'fake resource owner secret'}
 
 def test_DatabaseStore_start_background_does_not_insert_extra_row(database_connection_params):
     store = DatabaseStore(database_connection_params)
     open_batch = store.store_batch(newBatch1, fake_session)
     store.start_background(open_batch, fake_session)
     with store.connect() as connection, connection.cursor() as cursor:
         cursor.execute('SELECT `background_id`, `background_started_utc_timestamp` FROM `background`')
         assert cursor.rowcount == 1
         background_id, background_started_utc_timestamp = cursor.fetchone()
     store.start_background(open_batch, fake_session) # should be no-op
     with store.connect() as connection, connection.cursor() as cursor:
         cursor.execute('SELECT `background_id`, `background_started_utc_timestamp` FROM `background`')
         assert cursor.rowcount == 1
         assert (background_id, background_started_utc_timestamp) == cursor.fetchone()
 
 def test_DatabaseStore_stop_background_updates_row_removes_auth(database_connection_params):
     store = DatabaseStore(database_connection_params)
     open_batch = store.store_batch(newBatch1, fake_session)
     store.start_background(open_batch, fake_session)
     store.stop_background(open_batch, fake_session)
     with store.connect() as connection, connection.cursor() as cursor:
         cursor.execute('SELECT `background_auth`, `background_stopped_utc_timestamp`, `localuser_user_name` FROM `background` JOIN `localuser` ON `background_stopped_localuser_id` = `localuser_id`')
         assert cursor.rowcount == 1
         auth, stopped_utc_timestamp, stopped_user_name = cursor.fetchone()
         assert stopped_utc_timestamp > 0
         assert stopped_user_name == 'Lucas Werkmeister'
         assert auth is None
 
 def test_DatabaseStore_stop_background_without_session(database_connection_params):
     store = DatabaseStore(database_connection_params)
     open_batch = store.store_batch(newBatch1, fake_session)
     store.start_background(open_batch, fake_session)
     store.stop_background(open_batch)
     with store.connect() as connection, connection.cursor() as cursor:
         cursor.execute('SELECT `background_stopped_utc_timestamp`, `background_stopped_localuser_id` FROM `background`')
         assert cursor.rowcount == 1
         stopped_utc_timestamp, stopped_localuser_id = cursor.fetchone()
         assert stopped_utc_timestamp > 0
         assert stopped_localuser_id is None
 
 def test_DatabaseStore_stop_background_multiple_closes_all_raises_exception(database_connection_params):
     store = DatabaseStore(database_connection_params)
     open_batch = store.store_batch(newBatch1, fake_session)
     store.start_background(open_batch, fake_session)
     with store.connect() as connection, connection.cursor() as cursor:
         cursor.execute('INSERT INTO `background` (`background_batch`, `background_auth`, `background_started_utc_timestamp`, `background_started_localuser_id`) SELECT `background_batch`, `background_auth`, `background_started_utc_timestamp`, `background_started_localuser_id` FROM `background`')
         connection.commit()
     with pytest.raises(RuntimeError, match='Should have stopped at most 1 background operation, actually affected 2!'):
         store.stop_background(open_batch)
     with store.connect() as connection, connection.cursor() as cursor:
         cursor.execute('SELECT 1 FROM `background` WHERE `background_stopped_utc_timestamp` IS NOT NULL')
         assert cursor.rowcount == 2
         cursor.execute('SELECT 1 FROM `background` WHERE `background_stopped_utc_timestamp` IS NULL')
         assert cursor.rowcount == 0
 
 def test_DatabaseStore_closing_batch_stops_background(database_connection_params):
     store = DatabaseStore(database_connection_params)
     open_batch = store.store_batch(newBatch1, fake_session)
     store.start_background(open_batch, fake_session)
     [command_record_1, command_record_2] = open_batch.command_records.get_slice(0, 2)
     open_batch.command_records.store_finish(CommandNoop(command_record_1.id, command_record_1.command, revision=1))
     open_batch.command_records.store_finish(CommandNoop(command_record_2.id, command_record_2.command, revision=2))
     with store.connect() as connection, connection.cursor() as cursor:
         cursor.execute('SELECT `background_stopped_utc_timestamp`, `background_stopped_localuser_id` FROM `background`')
         assert cursor.rowcount == 1
         stopped_utc_timestamp, stopped_localuser_id = cursor.fetchone()
         assert stopped_utc_timestamp > 0
         assert stopped_localuser_id is None
 
 
 command_unfinishes_and_rows = [
     (commandPlan1, (DatabaseStore._COMMAND_STATUS_PLAN, None)),
     (commandPending1, (DatabaseStore._COMMAND_STATUS_PENDING, None)),
 ] # type: List[Tuple[CommandRecord, Tuple[int, Optional[dict]]]]
 command_finishes_and_rows = [
     (commandEdit1, (DatabaseStore._COMMAND_STATUS_EDIT, {'base_revision': 1234, 'revision': 1235})),
     (commandNoop1, (DatabaseStore._COMMAND_STATUS_NOOP, {'revision': 1234})),
     (commandPageMissing1, (DatabaseStore._COMMAND_STATUS_PAGE_MISSING, {'curtimestamp': '2019-03-11T23:26:02Z'})),
+    (commandTitleInvalid1, (DatabaseStore._COMMAND_STATUS_TITLE_INVALID, {'curtimestamp': '2019-03-11T23:26:02Z'})),
     (commandPageProtected1, (DatabaseStore._COMMAND_STATUS_PAGE_PROTECTED, {'curtimestamp': '2019-03-11T23:26:02Z'})),
     (commandEditConflict1, (DatabaseStore._COMMAND_STATUS_EDIT_CONFLICT, {})),
     (commandMaxlagExceeded1, (DatabaseStore._COMMAND_STATUS_MAXLAG_EXCEEDED, {'retry_after_utc_timestamp': 1552749842})),
     (commandBlocked1, (DatabaseStore._COMMAND_STATUS_BLOCKED, {'auto': False, 'blockinfo': blockinfo})),
     (commandBlocked2, (DatabaseStore._COMMAND_STATUS_BLOCKED, {'auto': False, 'blockinfo': None})),
     (commandWikiReadOnly1, (DatabaseStore._COMMAND_STATUS_WIKI_READ_ONLY, {'reason': 'maintenance', 'retry_after_utc_timestamp': 1552749842})),
     (commandWikiReadOnly2, (DatabaseStore._COMMAND_STATUS_WIKI_READ_ONLY, {'reason': None})),
 ] # type: List[Tuple[CommandRecord, Tuple[int, Optional[dict]]]]
 
 @pytest.mark.parametrize('command_finish, expected_row', command_finishes_and_rows)
 def test_DatabaseStore_command_finish_to_row(command_finish, expected_row):
     actual_row = DatabaseStore({})._command_finish_to_row(command_finish)
     assert expected_row == actual_row
 
 @pytest.mark.parametrize('expected_command_record, row', command_unfinishes_and_rows + command_finishes_and_rows)
 def test_DatabaseStore_row_to_command_record(expected_command_record, row):
     status, outcome = row
     outcome_json = json.dumps(outcome) if outcome else None
     full_row = expected_command_record.id, expected_command_record.command.page, expected_command_record.command.actions_tpsv(), status, outcome_json
     actual_command_record = DatabaseStore({})._row_to_command_record(*full_row)
     assert expected_command_record == actual_command_record
 
 
 def test_LocalUserStore_store_two_users(database_connection_params):
     connection = pymysql.connect(**database_connection_params)
     try:
         domain_store = StringTableStore('domain', 'domain_id', 'domain_hash', 'domain_name')
         local_user_store = _LocalUserStore(domain_store)
 
         localuser_id_1 = local_user_store.acquire_localuser_id(connection, localUser1)
         localuser_id_2 = local_user_store.acquire_localuser_id(connection, localUser2)
 
         assert localuser_id_1 != localuser_id_2
 
         with connection.cursor() as cursor:
             cursor.execute('''SELECT localuser_user_name, localuser_local_user_id, localuser_global_user_id
                               FROM localuser
                               WHERE localuser_id = %s''',
                            (localuser_id_1,))
             assert cursor.fetchone() == (localUser1.user_name, localUser1.local_user_id, localUser1.global_user_id)
 
         with connection.cursor() as cursor:
             cursor.execute('''SELECT localuser_user_name, localuser_local_user_id, localuser_global_user_id
                               FROM localuser
                               WHERE localuser_id = %s''',
                            (localuser_id_2,))
             assert cursor.fetchone() == (localUser2.user_name, localUser2.local_user_id, localUser2.global_user_id)
     finally:
         connection.close()
 
 def test_LocalUserStore_store_same_user_twice(database_connection_params):
     connection = pymysql.connect(**database_connection_params)
     try:
         domain_store = StringTableStore('domain', 'domain_id', 'domain_hash', 'domain_name')
         local_user_store = _LocalUserStore(domain_store)
 
         localuser_id_1 = local_user_store.acquire_localuser_id(connection, localUser1)
         localuser_id_2 = local_user_store.acquire_localuser_id(connection, localUser1)
 
         assert localuser_id_1 == localuser_id_2
 
         with connection.cursor() as cursor:
             cursor.execute('''SELECT localuser_user_name, localuser_local_user_id, localuser_global_user_id
                               FROM localuser
                               WHERE localuser_id = %s''',
                            (localuser_id_1,))
             assert cursor.fetchone() == (localUser1.user_name, localUser1.local_user_id, localUser1.global_user_id)
     finally:
         connection.close()
 
 def test_LocalUserStore_store_renamed_user(database_connection_params):
     connection = pymysql.connect(**database_connection_params)
     try:
         domain_store = StringTableStore('domain', 'domain_id', 'domain_hash', 'domain_name')
         local_user_store = _LocalUserStore(domain_store)
 
         localuser_id_1 = local_user_store.acquire_localuser_id(connection, localUser1)
         localuser_id_2 = local_user_store.acquire_localuser_id(connection, LocalUser(localUser1.user_name + ' (renamed)',
                                                                                      localUser1.domain,
                                                                                      localUser1.local_user_id,
                                                                                      localUser1.global_user_id))
 
         assert localuser_id_1 == localuser_id_2
 
         with connection.cursor() as cursor:
             cursor.execute('''SELECT localuser_user_name, localuser_local_user_id, localuser_global_user_id
                               FROM localuser
                               WHERE localuser_id = %s''',
                            (localuser_id_1,))
             assert cursor.fetchone() == (localUser1.user_name + ' (renamed)', localUser1.local_user_id, localUser1.global_user_id)
     finally:
         connection.close()
diff --git a/test_runner.py b/test_runner.py
index 966a186..f0b8bf8 100644
--- a/test_runner.py
+++ b/test_runner.py
@@ -1,657 +1,710 @@
 import datetime
 import mwapi # type: ignore
 import os
 import pytest # type: ignore
 
 from action import AddCategoryAction, RemoveCategoryAction
-from command import Command, CommandPending, CommandEdit, CommandNoop, CommandPageMissing, CommandPageProtected, CommandEditConflict, CommandMaxlagExceeded, CommandBlocked, CommandWikiReadOnly
+from command import Command, CommandPending, CommandEdit, CommandNoop, CommandPageMissing, CommandTitleInvalid, CommandPageProtected, CommandEditConflict, CommandMaxlagExceeded, CommandBlocked, CommandWikiReadOnly
 from runner import Runner
 
 from test_utils import FakeSession
 
 def test_run_command():
     if 'MW_USERNAME' not in os.environ or 'MW_PASSWORD' not in os.environ:
         pytest.skip('MediaWiki credentials not provided')
     session = mwapi.Session('https://test.wikipedia.org', user_agent='QuickCategories test (mail@lucaswerkmeister.de)')
     lgtoken = session.get(action='query',
                           meta='tokens',
                           type=['login'])['query']['tokens']['logintoken']
     session.post(action='login',
                  lgname=os.environ['MW_USERNAME'],
                  lgpassword=os.environ['MW_PASSWORD'],
                  lgtoken=lgtoken)
 
     title = 'QuickCategories CI Test'
     if 'TRAVIS_JOB_NUMBER' in os.environ:
         job_number = os.environ['TRAVIS_JOB_NUMBER']
         title += '/' + job_number[job_number.index('.')+1:]
 
     command = Command(title, [AddCategoryAction('Added cat'),
                               AddCategoryAction('Already present cat'),
                               RemoveCategoryAction('Removed cat'),
                               RemoveCategoryAction('Not present cat')])
     runner = Runner(session, summary_batch_title='QuickCategories CI test')
     csrftoken = session.get(action='query',
                             meta='tokens')['query']['tokens']['csrftoken']
     setup_edit = session.post(**{'action': 'edit',
                                  'title': command.page,
                                  'text': 'Test page for the QuickCategories tool.\n[[Category:Already present cat]]\n[[Category:Removed cat]]\nBottom text',
                                  'summary': 'setup',
                                  'token': csrftoken,
                                  'assert': 'user'})
     edit = runner.run_command(CommandPending(0, command))
 
     assert isinstance(edit, CommandEdit)
     assert edit.base_revision == setup_edit['edit']['newrevid']
     assert command.page not in runner.prepared_pages
 
     actual_revision = session.get(action='query',
                                   revids=[edit.revision],
                                   prop=['revisions'],
                                   rvprop=['content', 'flags', 'comment'],
                                   rvslots=['main'],
                                   formatversion=2)['query']['pages'][0]['revisions'][0]
     actual_content = actual_revision['slots']['main']['content']
     actual_comment = actual_revision['comment']
     session.post(**{'action': 'edit',
                     'title': command.page,
                     'text': 'Test page for the QuickCategories tool.',
                     'summary': 'teardown',
                     'token': csrftoken,
                     'assert': 'user'})
     expected_content = 'Test page for the QuickCategories tool.\n[[Category:Already present cat]]\n[[Category:Added cat]]\nBottom text'
     assert expected_content == actual_content
     assert not actual_revision['minor']
     expected_comment = '+[[Category:Added cat]], (+[[Category:Already present cat]]), -[[Category:Removed cat]], (-[[Category:Not present cat]]); QuickCategories CI test'
     assert expected_comment == actual_comment
 
 def test_with_nochange():
     curtimestamp = '2019-03-11T23:33:30Z'
     session = FakeSession(
         {
             'curtimestamp': curtimestamp,
             'query': {
                 'tokens': {'csrftoken': '+\\'},
                 'pages': [
                     {
                         'pageid': 58692,
                         'ns': 0,
                         'title': 'Main page',
                         'revisions': [
                             {
                                 'revid': 195259,
                                 'parentid': 114947,
                                 'timestamp': '2014-02-23T15:14:40Z',
                                 'slots': {
                                     'main': {
                                         'contentmodel': 'wikitext',
                                         'contentformat': 'text/x-wiki',
                                         'content': 'Unit Testing 1, 2, 3... External link: http://some-fake-site.com/?p=1774943982 Hit me with a captcha...',
                                     },
                                 },
                             },
                         ],
                     },
                 ],
                 'namespaces': {
                     '14': {
                         'id': 14,
                         'name': 'Category',
                         'canonical': 'Category',
                         'case': 'first-letter',
                     },
                 },
                 'namespacealiases': [],
                 'allmessages': [
                     {
                         'name': 'comma-separator',
                         'content': ', ',
                     },
                     {
                         'name': 'semicolon-separator',
                         'content': '; ',
                     },
                     {
                         'name': 'parentheses',
                         'content': '($1)',
                     },
                 ],
             },
         },
         {
             'edit': {
                 'result': 'Success',
                 'pageid': 58692,
                 'title': 'Main page',
                 'contentmodel': 'wikitext',
                 'nochange': ''
             }
         }
     )
     session.host = 'test.wikidata.org'
     runner = Runner(session)
 
     command_pending = CommandPending(0, Command('Main page', [AddCategoryAction('Added cat')]))
     command_record = runner.run_command(command_pending)
 
     assert isinstance(command_record, CommandNoop)
     assert command_record.revision == 195259
     assert 'Main page' not in runner.prepared_pages
 
 def test_with_missing_page():
     curtimestamp = '2019-03-11T23:33:30Z'
     session = FakeSession({
         'curtimestamp': curtimestamp,
         'query': {
             'tokens': {'csrftoken': '+\\'},
             'pages': [
                 {
                     'ns': 0,
                     'title': 'Missing page',
                     'missing': True,
                 },
             ],
             'namespaces': {
                 '14': {
                     'id': 14,
                     'name': 'Category',
                     'canonical': 'Category',
                     'case': 'first-letter',
                 },
             },
             'namespacealiases': [],
             'allmessages': [
                 {
                     'name': 'comma-separator',
                     'content': ', ',
                 },
                 {
                     'name': 'semicolon-separator',
                     'content': '; ',
                 },
                 {
                     'name': 'parentheses',
                     'content': '($1)',
                 },
             ],
         },
     })
     session.host = 'test.wikidata.org'
     runner = Runner(session)
 
     runner.prepare_pages(['Missing page'])
 
     assert runner.prepared_pages['Missing page'] == {
         'missing': True,
         'curtimestamp': curtimestamp,
     }
 
     command_pending = CommandPending(0, Command('Missing page', [AddCategoryAction('Added cat')]))
     command_record = runner.run_command(command_pending)
 
     assert command_record == CommandPageMissing(command_pending.id, command_pending.command, curtimestamp)
 
 def test_with_missing_page_unnormalized():
     curtimestamp = '2019-03-11T23:33:30Z'
     session = FakeSession({
         'curtimestamp': curtimestamp,
         'query': {
             'tokens': {'csrftoken': '+\\'},
             'pages': [
                 {
                     'ns': 0,
                     'title': 'Missing page',
                     'missing': True,
                 },
             ],
             'normalized': [
                 {
                     'from': 'missing page',
                     'to': 'Missing page',
                 },
             ],
             'namespaces': {
                 '14': {
                     'id': 14,
                     'name': 'Category',
                     'canonical': 'Category',
                     'case': 'first-letter',
                 },
             },
             'namespacealiases': [],
             'allmessages': [
                 {
                     'name': 'comma-separator',
                     'content': ', ',
                 },
                 {
                     'name': 'semicolon-separator',
                     'content': '; ',
                 },
                 {
                     'name': 'parentheses',
                     'content': '($1)',
                 },
             ],
         },
     })
     session.host = 'test.wikidata.org'
     runner = Runner(session)
 
     runner.prepare_pages(['missing page'])
 
     assert runner.prepared_pages['missing page'] == {
         'missing': True,
         'curtimestamp': curtimestamp,
     }
 
     command_pending = CommandPending(0, Command('missing page', [AddCategoryAction('Added cat')]))
     command_record = runner.run_command(command_pending)
 
     assert command_record == CommandPageMissing(command_pending.id, command_pending.command, curtimestamp)
 
+def test_with_invalid_title():
+    curtimestamp = '2019-03-11T23:33:30Z'
+    session = FakeSession({
+        'curtimestamp': curtimestamp,
+        'query': {
+            'tokens': {'csrftoken': '+\\'},
+            'pages': [
+                {
+                    'title': 'Invalid%20title',
+                    'invalidreason': 'The requested page title contains invalid characters: "%20".',
+                    'invalid': True,
+                },
+            ],
+            'namespaces': {
+                '14': {
+                    'id': 14,
+                    'name': 'Category',
+                    'canonical': 'Category',
+                    'case': 'first-letter',
+                },
+            },
+            'namespacealiases': [],
+            'allmessages': [
+                {
+                    'name': 'comma-separator',
+                    'content': ', ',
+                },
+                {
+                    'name': 'semicolon-separator',
+                    'content': '; ',
+                },
+                {
+                    'name': 'parentheses',
+                    'content': '($1)',
+                },
+            ],
+        },
+    })
+    session.host = 'test.wikidata.org'
+    runner = Runner(session)
+
+    runner.prepare_pages(['Invalid%20title'])
+
+    assert runner.prepared_pages['Invalid%20title'] == {
+        'invalid': True,
+        'curtimestamp': curtimestamp,
+    }
+
+    command_pending = CommandPending(0, Command('Invalid%20title', [AddCategoryAction('Added cat')]))
+    command_record = runner.run_command(command_pending)
+
+    assert command_record == CommandTitleInvalid(command_pending.id, command_pending.command, curtimestamp)
+
 def test_with_protected_page():
     curtimestamp = '2019-03-11T23:33:30Z'
     session = FakeSession(
         {
             'curtimestamp': curtimestamp,
             'query': {
                 'tokens': {'csrftoken': '+\\'},
                 'pages': [
                     {
                         'pageid': 58692,
                         'ns': 0,
                         'title': 'Main page',
                         'revisions': [
                             {
                                 'revid': 195259,
                                 'parentid': 114947,
                                 'timestamp': '2014-02-23T15:14:40Z',
                                 'slots': {
                                     'main': {
                                         'contentmodel': 'wikitext',
                                         'contentformat': 'text/x-wiki',
                                         'content': 'Unit Testing 1, 2, 3... External link: http://some-fake-site.com/?p=1774943982 Hit me with a captcha...',
                                     },
                                 },
                             },
                         ],
                     },
                 ],
                 'namespaces': {
                     '14': {
                         'id': 14,
                         'name': 'Category',
                         'canonical': 'Category',
                         'case': 'first-letter',
                     },
                 },
                 'namespacealiases': [],
                 'allmessages': [
                     {
                         'name': 'comma-separator',
                         'content': ', ',
                     },
                     {
                         'name': 'semicolon-separator',
                         'content': '; ',
                     },
                     {
                         'name': 'parentheses',
                         'content': '($1)',
                     },
                 ],
             },
         },
         mwapi.errors.APIError('protectedpage', 'This page has been protected to prevent editing or other actions.', None)
     )
     session.host = 'test.wikidata.org'
     runner = Runner(session)
 
     command_pending = CommandPending(0, Command('Main page', [AddCategoryAction('Added cat')]))
     command_record = runner.run_command(command_pending)
 
     assert command_record == CommandPageProtected(command_pending.id, command_pending.command, curtimestamp)
 
 def test_with_edit_conflict():
     curtimestamp = '2019-03-11T23:33:30Z'
     session = FakeSession(
         {
             'curtimestamp': curtimestamp,
             'query': {
                 'tokens': {'csrftoken': '+\\'},
                 'pages': [
                     {
                         'pageid': 58692,
                         'ns': 0,
                         'title': 'Main page',
                         'revisions': [
                             {
                                 'revid': 195259,
                                 'parentid': 114947,
                                 'timestamp': '2014-02-23T15:14:40Z',
                                 'slots': {
                                     'main': {
                                         'contentmodel': 'wikitext',
                                         'contentformat': 'text/x-wiki',
                                         'content': 'Unit Testing 1, 2, 3... External link: http://some-fake-site.com/?p=1774943982 Hit me with a captcha...',
                                     },
                                 },
                             },
                         ],
                     },
                 ],
                 'namespaces': {
                     '14': {
                         'id': 14,
                         'name': 'Category',
                         'canonical': 'Category',
                         'case': 'first-letter',
                     },
                 },
                 'namespacealiases': [],
                 'allmessages': [
                     {
                         'name': 'comma-separator',
                         'content': ', ',
                     },
                     {
                         'name': 'semicolon-separator',
                         'content': '; ',
                     },
                     {
                         'name': 'parentheses',
                         'content': '($1)',
                     },
                 ],
             },
         },
         mwapi.errors.APIError('editconflict', 'Edit conflict: $1', None)
     )
     session.host = 'test.wikidata.org'
     runner = Runner(session)
 
     runner.prepare_pages(['Main page'])
 
     assert 'Main page' in runner.prepared_pages
 
     command_pending = CommandPending(0, Command('Main page', [AddCategoryAction('Added cat')]))
     command_record = runner.run_command(command_pending)
 
     assert command_record == CommandEditConflict(command_pending.id, command_pending.command)
     assert 'Main page' not in runner.prepared_pages
 
 def test_with_maxlag_exceeded():
     curtimestamp = '2019-03-11T23:33:30Z'
     session = FakeSession(
         {
             'curtimestamp': curtimestamp,
             'query': {
                 'tokens': {'csrftoken': '+\\'},
                 'pages': [
                     {
                         'pageid': 58692,
                         'ns': 0,
                         'title': 'Main page',
                         'revisions': [
                             {
                                 'revid': 195259,
                                 'parentid': 114947,
                                 'timestamp': '2014-02-23T15:14:40Z',
                                 'slots': {
                                     'main': {
                                         'contentmodel': 'wikitext',
                                         'contentformat': 'text/x-wiki',
                                         'content': 'Unit Testing 1, 2, 3... External link: http://some-fake-site.com/?p=1774943982 Hit me with a captcha...',
                                     },
                                 },
                             },
                         ],
                     },
                 ],
                 'namespaces': {
                     '14': {
                         'id': 14,
                         'name': 'Category',
                         'canonical': 'Category',
                         'case': 'first-letter',
                     },
                 },
                 'namespacealiases': [],
                 'allmessages': [
                     {
                         'name': 'comma-separator',
                         'content': ', ',
                     },
                     {
                         'name': 'semicolon-separator',
                         'content': '; ',
                     },
                     {
                         'name': 'parentheses',
                         'content': '($1)',
                     },
                 ],
             },
         },
         mwapi.errors.APIError('maxlag', 'Waiting for 10.64.48.35: 0.36570191383362 seconds lagged.', None)
     )
     session.host = 'test.wikidata.org'
     runner = Runner(session)
 
     runner.prepare_pages(['Main page'])
 
     assert 'Main page' in runner.prepared_pages
 
     command_pending = CommandPending(0, Command('Main page', [AddCategoryAction('Added cat')]))
     command_record = runner.run_command(command_pending)
 
     assert isinstance(command_record, CommandMaxlagExceeded)
     assert command_record.retry_after.tzinfo == datetime.timezone.utc
     assert 'Main page' in runner.prepared_pages
 
 def test_with_blocked():
     curtimestamp = '2019-03-11T23:33:30Z'
     session = FakeSession(
         {
             'curtimestamp': curtimestamp,
             'query': {
                 'tokens': {'csrftoken': '+\\'},
                 'pages': [
                     {
                         'pageid': 58692,
                         'ns': 0,
                         'title': 'Main page',
                         'revisions': [
                             {
                                 'revid': 195259,
                                 'parentid': 114947,
                                 'timestamp': '2014-02-23T15:14:40Z',
                                 'slots': {
                                     'main': {
                                         'contentmodel': 'wikitext',
                                         'contentformat': 'text/x-wiki',
                                         'content': 'Unit Testing 1, 2, 3... External link: http://some-fake-site.com/?p=1774943982 Hit me with a captcha...',
                                     },
                                 },
                             },
                         ],
                     },
                 ],
                 'namespaces': {
                     '14': {
                         'id': 14,
                         'name': 'Category',
                         'canonical': 'Category',
                         'case': 'first-letter',
                     },
                 },
                 'namespacealiases': [],
                 'allmessages': [
                     {
                         'name': 'comma-separator',
                         'content': ', ',
                     },
                     {
                         'name': 'semicolon-separator',
                         'content': '; ',
                     },
                     {
                         'name': 'parentheses',
                         'content': '($1)',
                     },
                 ],
             },
         },
         mwapi.errors.APIError('blocked', 'You have been blocked from editing.', None)
     )
     session.host = 'test.wikidata.org'
     runner = Runner(session)
 
     runner.prepare_pages(['Main page'])
 
     assert 'Main page' in runner.prepared_pages
 
     command_pending = CommandPending(0, Command('Main page', [AddCategoryAction('Added cat')]))
     command_record = runner.run_command(command_pending)
 
     assert isinstance(command_record, CommandBlocked)
     assert not command_record.auto
     # would be nice to assert command_record.blockinfo once Runner can record it
 
 def test_with_autoblocked():
     curtimestamp = '2019-03-11T23:33:30Z'
     session = FakeSession(
         {
             'curtimestamp': curtimestamp,
             'query': {
                 'tokens': {'csrftoken': '+\\'},
                 'pages': [
                     {
                         'pageid': 58692,
                         'ns': 0,
                         'title': 'Main page',
                         'revisions': [
                             {
                                 'revid': 195259,
                                 'parentid': 114947,
                                 'timestamp': '2014-02-23T15:14:40Z',
                                 'slots': {
                                     'main': {
                                         'contentmodel': 'wikitext',
                                         'contentformat': 'text/x-wiki',
                                         'content': 'Unit Testing 1, 2, 3... External link: http://some-fake-site.com/?p=1774943982 Hit me with a captcha...',
                                     },
                                 },
                             },
                         ],
                     },
                 ],
                 'namespaces': {
                     '14': {
                         'id': 14,
                         'name': 'Category',
                         'canonical': 'Category',
                         'case': 'first-letter',
                     },
                 },
                 'namespacealiases': [],
                 'allmessages': [
                     {
                         'name': 'comma-separator',
                         'content': ', ',
                     },
                     {
                         'name': 'semicolon-separator',
                         'content': '; ',
                     },
                     {
                         'name': 'parentheses',
                         'content': '($1)',
                     },
                 ],
             },
         },
         mwapi.errors.APIError('autoblocked', 'Your IP address has been blocked automatically, because it was used by a blocked user.', None)
     )
     session.host = 'test.wikidata.org'
     runner = Runner(session)
 
     runner.prepare_pages(['Main page'])
 
     assert 'Main page' in runner.prepared_pages
 
     command_pending = CommandPending(0, Command('Main page', [AddCategoryAction('Added cat')]))
     command_record = runner.run_command(command_pending)
 
     assert isinstance(command_record, CommandBlocked)
     assert command_record.auto
     # would be nice to assert command_record.blockinfo once Runner can record it
 
 def test_with_readonly():
     curtimestamp = '2019-03-11T23:33:30Z'
     session = FakeSession(
         {
             'curtimestamp': curtimestamp,
             'query': {
                 'tokens': {'csrftoken': '+\\'},
                 'pages': [
                     {
                         'pageid': 58692,
                         'ns': 0,
                         'title': 'Main page',
                         'revisions': [
                             {
                                 'revid': 195259,
                                 'parentid': 114947,
                                 'timestamp': '2014-02-23T15:14:40Z',
                                 'slots': {
                                     'main': {
                                         'contentmodel': 'wikitext',
                                         'contentformat': 'text/x-wiki',
                                         'content': 'Unit Testing 1, 2, 3... External link: http://some-fake-site.com/?p=1774943982 Hit me with a captcha...',
                                     },
                                 },
                             },
                         ],
                     },
                 ],
                 'namespaces': {
                     '14': {
                         'id': 14,
                         'name': 'Category',
                         'canonical': 'Category',
                         'case': 'first-letter',
                     },
                 },
                 'namespacealiases': [],
                 'allmessages': [
                     {
                         'name': 'comma-separator',
                         'content': ', ',
                     },
                     {
                         'name': 'semicolon-separator',
                         'content': '; ',
                     },
                     {
                         'name': 'parentheses',
                         'content': '($1)',
                     },
                 ],
             },
         },
         mwapi.errors.APIError('readonly', 'The wiki is currently in read-only mode.', None)
     )
     session.host = 'test.wikidata.org'
     runner = Runner(session)
 
     runner.prepare_pages(['Main page'])
 
     assert 'Main page' in runner.prepared_pages
 
     command_pending = CommandPending(0, Command('Main page', [AddCategoryAction('Added cat')]))
     command_record = runner.run_command(command_pending)
 
     assert isinstance(command_record, CommandWikiReadOnly)
     # would be nice to assert command_record.reason once Runner can record it