iOS 2.5.1 - Fixed Camera Rotation

iOS 2.5.0 - Apple Music Integration
Update LICENSE
2025-12-12 00:38:24 -07:00 · 2025-12-08 15:31:09 -07:00 · 2025-12-08 18:21:35 +00:00 · 2025-12-08 18:20:33 +00:00 · 2025-12-07 01:43:19 -07:00 · 2025-12-03 15:45:05 -07:00
50 changed files with 4444 additions and 2901 deletions
--- a/674
+++ b/674
@@ -0,0 +1,674 @@
+                    GNU GENERAL PUBLIC LICENSE
+                       Version 3, 29 June 2007
+
+ Copyright (C) 2007 Free Software Foundation, Inc. <https://fsf.org/>
+ Everyone is permitted to copy and distribute verbatim copies
+ of this license document, but changing it is not allowed.
+
+                            Preamble
+
+  The GNU General Public License is a free, copyleft license for
+software and other kinds of works.
+
+  The licenses for most software and other practical works are designed
+to take away your freedom to share and change the works.  By contrast,
+the GNU General Public License is intended to guarantee your freedom to
+share and change all versions of a program--to make sure it remains free
+software for all its users.  We, the Free Software Foundation, use the
+GNU General Public License for most of our software; it applies also to
+any other work released this way by its authors.  You can apply it to
+your programs, too.
+
+  When we speak of free software, we are referring to freedom, not
+price.  Our General Public Licenses are designed to make sure that you
+have the freedom to distribute copies of free software (and charge for
+them if you wish), that you receive source code or can get it if you
+want it, that you can change the software or use pieces of it in new
+free programs, and that you know you can do these things.
+
+  To protect your rights, we need to prevent others from denying you
+these rights or asking you to surrender the rights.  Therefore, you have
+certain responsibilities if you distribute copies of the software, or if
+you modify it: responsibilities to respect the freedom of others.
+
+  For example, if you distribute copies of such a program, whether
+gratis or for a fee, you must pass on to the recipients the same
+freedoms that you received.  You must make sure that they, too, receive
+or can get the source code.  And you must show them these terms so they
+know their rights.
+
+  Developers that use the GNU GPL protect your rights with two steps:
+(1) assert copyright on the software, and (2) offer you this License
+giving you legal permission to copy, distribute and/or modify it.
+
+  For the developers' and authors' protection, the GPL clearly explains
+that there is no warranty for this free software.  For both users' and
+authors' sake, the GPL requires that modified versions be marked as
+changed, so that their problems will not be attributed erroneously to
+authors of previous versions.
+
+  Some devices are designed to deny users access to install or run
+modified versions of the software inside them, although the manufacturer
+can do so.  This is fundamentally incompatible with the aim of
+protecting users' freedom to change the software.  The systematic
+pattern of such abuse occurs in the area of products for individuals to
+use, which is precisely where it is most unacceptable.  Therefore, we
+have designed this version of the GPL to prohibit the practice for those
+products.  If such problems arise substantially in other domains, we
+stand ready to extend this provision to those domains in future versions
+of the GPL, as needed to protect the freedom of users.
+
+  Finally, every program is threatened constantly by software patents.
+States should not allow patents to restrict development and use of
+software on general-purpose computers, but in those that do, we wish to
+avoid the special danger that patents applied to a free program could
+make it effectively proprietary.  To prevent this, the GPL assures that
+patents cannot be used to render the program non-free.
+
+  The precise terms and conditions for copying, distribution and
+modification follow.
+
+                       TERMS AND CONDITIONS
+
+  0. Definitions.
+
+  "This License" refers to version 3 of the GNU General Public License.
+
+  "Copyright" also means copyright-like laws that apply to other kinds of
+works, such as semiconductor masks.
+
+  "The Program" refers to any copyrightable work licensed under this
+License.  Each licensee is addressed as "you".  "Licensees" and
+"recipients" may be individuals or organizations.
+
+  To "modify" a work means to copy from or adapt all or part of the work
+in a fashion requiring copyright permission, other than the making of an
+exact copy.  The resulting work is called a "modified version" of the
+earlier work or a work "based on" the earlier work.
+
+  A "covered work" means either the unmodified Program or a work based
+on the Program.
+
+  To "propagate" a work means to do anything with it that, without
+permission, would make you directly or secondarily liable for
+infringement under applicable copyright law, except executing it on a
+computer or modifying a private copy.  Propagation includes copying,
+distribution (with or without modification), making available to the
+public, and in some countries other activities as well.
+
+  To "convey" a work means any kind of propagation that enables other
+parties to make or receive copies.  Mere interaction with a user through
+a computer network, with no transfer of a copy, is not conveying.
+
+  An interactive user interface displays "Appropriate Legal Notices"
+to the extent that it includes a convenient and prominently visible
+feature that (1) displays an appropriate copyright notice, and (2)
+tells the user that there is no warranty for the work (except to the
+extent that warranties are provided), that licensees may convey the
+work under this License, and how to view a copy of this License.  If
+the interface presents a list of user commands or options, such as a
+menu, a prominent item in the list meets this criterion.
+
+  1. Source Code.
+
+  The "source code" for a work means the preferred form of the work
+for making modifications to it.  "Object code" means any non-source
+form of a work.
+
+  A "Standard Interface" means an interface that either is an official
+standard defined by a recognized standards body, or, in the case of
+interfaces specified for a particular programming language, one that
+is widely used among developers working in that language.
+
+  The "System Libraries" of an executable work include anything, other
+than the work as a whole, that (a) is included in the normal form of
+packaging a Major Component, but which is not part of that Major
+Component, and (b) serves only to enable use of the work with that
+Major Component, or to implement a Standard Interface for which an
+implementation is available to the public in source code form.  A
+"Major Component", in this context, means a major essential component
+(kernel, window system, and so on) of the specific operating system
+(if any) on which the executable work runs, or a compiler used to
+produce the work, or an object code interpreter used to run it.
+
+  The "Corresponding Source" for a work in object code form means all
+the source code needed to generate, install, and (for an executable
+work) run the object code and to modify the work, including scripts to
+control those activities.  However, it does not include the work's
+System Libraries, or general-purpose tools or generally available free
+programs which are used unmodified in performing those activities but
+which are not part of the work.  For example, Corresponding Source
+includes interface definition files associated with source files for
+the work, and the source code for shared libraries and dynamically
+linked subprograms that the work is specifically designed to require,
+such as by intimate data communication or control flow between those
+subprograms and other parts of the work.
+
+  The Corresponding Source need not include anything that users
+can regenerate automatically from other parts of the Corresponding
+Source.
+
+  The Corresponding Source for a work in source code form is that
+same work.
+
+  2. Basic Permissions.
+
+  All rights granted under this License are granted for the term of
+copyright on the Program, and are irrevocable provided the stated
+conditions are met.  This License explicitly affirms your unlimited
+permission to run the unmodified Program.  The output from running a
+covered work is covered by this License only if the output, given its
+content, constitutes a covered work.  This License acknowledges your
+rights of fair use or other equivalent, as provided by copyright law.
+
+  You may make, run and propagate covered works that you do not
+convey, without conditions so long as your license otherwise remains
+in force.  You may convey covered works to others for the sole purpose
+of having them make modifications exclusively for you, or provide you
+with facilities for running those works, provided that you comply with
+the terms of this License in conveying all material for which you do
+not control copyright.  Those thus making or running the covered works
+for you must do so exclusively on your behalf, under your direction
+and control, on terms that prohibit them from making any copies of
+your copyrighted material outside their relationship with you.
+
+  Conveying under any other circumstances is permitted solely under
+the conditions stated below.  Sublicensing is not allowed; section 10
+makes it unnecessary.
+
+  3. Protecting Users' Legal Rights From Anti-Circumvention Law.
+
+  No covered work shall be deemed part of an effective technological
+measure under any applicable law fulfilling obligations under article
+11 of the WIPO copyright treaty adopted on 20 December 1996, or
+similar laws prohibiting or restricting circumvention of such
+measures.
+
+  When you convey a covered work, you waive any legal power to forbid
+circumvention of technological measures to the extent such circumvention
+is effected by exercising rights under this License with respect to
+the covered work, and you disclaim any intention to limit operation or
+modification of the work as a means of enforcing, against the work's
+users, your or third parties' legal rights to forbid circumvention of
+technological measures.
+
+  4. Conveying Verbatim Copies.
+
+  You may convey verbatim copies of the Program's source code as you
+receive it, in any medium, provided that you conspicuously and
+appropriately publish on each copy an appropriate copyright notice;
+keep intact all notices stating that this License and any
+non-permissive terms added in accord with section 7 apply to the code;
+keep intact all notices of the absence of any warranty; and give all
+recipients a copy of this License along with the Program.
+
+  You may charge any price or no price for each copy that you convey,
+and you may offer support or warranty protection for a fee.
+
+  5. Conveying Modified Source Versions.
+
+  You may convey a work based on the Program, or the modifications to
+produce it from the Program, in the form of source code under the
+terms of section 4, provided that you also meet all of these conditions:
+
+    a) The work must carry prominent notices stating that you modified
+    it, and giving a relevant date.
+
+    b) The work must carry prominent notices stating that it is
+    released under this License and any conditions added under section
+    7.  This requirement modifies the requirement in section 4 to
+    "keep intact all notices".
+
+    c) You must license the entire work, as a whole, under this
+    License to anyone who comes into possession of a copy.  This
+    License will therefore apply, along with any applicable section 7
+    additional terms, to the whole of the work, and all its parts,
+    regardless of how they are packaged.  This License gives no
+    permission to license the work in any other way, but it does not
+    invalidate such permission if you have separately received it.
+
+    d) If the work has interactive user interfaces, each must display
+    Appropriate Legal Notices; however, if the Program has interactive
+    interfaces that do not display Appropriate Legal Notices, your
+    work need not make them do so.
+
+  A compilation of a covered work with other separate and independent
+works, which are not by their nature extensions of the covered work,
+and which are not combined with it such as to form a larger program,
+in or on a volume of a storage or distribution medium, is called an
+"aggregate" if the compilation and its resulting copyright are not
+used to limit the access or legal rights of the compilation's users
+beyond what the individual works permit.  Inclusion of a covered work
+in an aggregate does not cause this License to apply to the other
+parts of the aggregate.
+
+  6. Conveying Non-Source Forms.
+
+  You may convey a covered work in object code form under the terms
+of sections 4 and 5, provided that you also convey the
+machine-readable Corresponding Source under the terms of this License,
+in one of these ways:
+
+    a) Convey the object code in, or embodied in, a physical product
+    (including a physical distribution medium), accompanied by the
+    Corresponding Source fixed on a durable physical medium
+    customarily used for software interchange.
+
+    b) Convey the object code in, or embodied in, a physical product
+    (including a physical distribution medium), accompanied by a
+    written offer, valid for at least three years and valid for as
+    long as you offer spare parts or customer support for that product
+    model, to give anyone who possesses the object code either (1) a
+    copy of the Corresponding Source for all the software in the
+    product that is covered by this License, on a durable physical
+    medium customarily used for software interchange, for a price no
+    more than your reasonable cost of physically performing this
+    conveying of source, or (2) access to copy the
+    Corresponding Source from a network server at no charge.
+
+    c) Convey individual copies of the object code with a copy of the
+    written offer to provide the Corresponding Source.  This
+    alternative is allowed only occasionally and noncommercially, and
+    only if you received the object code with such an offer, in accord
+    with subsection 6b.
+
+    d) Convey the object code by offering access from a designated
+    place (gratis or for a charge), and offer equivalent access to the
+    Corresponding Source in the same way through the same place at no
+    further charge.  You need not require recipients to copy the
+    Corresponding Source along with the object code.  If the place to
+    copy the object code is a network server, the Corresponding Source
+    may be on a different server (operated by you or a third party)
+    that supports equivalent copying facilities, provided you maintain
+    clear directions next to the object code saying where to find the
+    Corresponding Source.  Regardless of what server hosts the
+    Corresponding Source, you remain obligated to ensure that it is
+    available for as long as needed to satisfy these requirements.
+
+    e) Convey the object code using peer-to-peer transmission, provided
+    you inform other peers where the object code and Corresponding
+    Source of the work are being offered to the general public at no
+    charge under subsection 6d.
+
+  A separable portion of the object code, whose source code is excluded
+from the Corresponding Source as a System Library, need not be
+included in conveying the object code work.
+
+  A "User Product" is either (1) a "consumer product", which means any
+tangible personal property which is normally used for personal, family,
+or household purposes, or (2) anything designed or sold for incorporation
+into a dwelling.  In determining whether a product is a consumer product,
+doubtful cases shall be resolved in favor of coverage.  For a particular
+product received by a particular user, "normally used" refers to a
+typical or common use of that class of product, regardless of the status
+of the particular user or of the way in which the particular user
+actually uses, or expects or is expected to use, the product.  A product
+is a consumer product regardless of whether the product has substantial
+commercial, industrial or non-consumer uses, unless such uses represent
+the only significant mode of use of the product.
+
+  "Installation Information" for a User Product means any methods,
+procedures, authorization keys, or other information required to install
+and execute modified versions of a covered work in that User Product from
+a modified version of its Corresponding Source.  The information must
+suffice to ensure that the continued functioning of the modified object
+code is in no case prevented or interfered with solely because
+modification has been made.
+
+  If you convey an object code work under this section in, or with, or
+specifically for use in, a User Product, and the conveying occurs as
+part of a transaction in which the right of possession and use of the
+User Product is transferred to the recipient in perpetuity or for a
+fixed term (regardless of how the transaction is characterized), the
+Corresponding Source conveyed under this section must be accompanied
+by the Installation Information.  But this requirement does not apply
+if neither you nor any third party retains the ability to install
+modified object code on the User Product (for example, the work has
+been installed in ROM).
+
+  The requirement to provide Installation Information does not include a
+requirement to continue to provide support service, warranty, or updates
+for a work that has been modified or installed by the recipient, or for
+the User Product in which it has been modified or installed.  Access to a
+network may be denied when the modification itself materially and
+adversely affects the operation of the network or violates the rules and
+protocols for communication across the network.
+
+  Corresponding Source conveyed, and Installation Information provided,
+in accord with this section must be in a format that is publicly
+documented (and with an implementation available to the public in
+source code form), and must require no special password or key for
+unpacking, reading or copying.
+
+  7. Additional Terms.
+
+  "Additional permissions" are terms that supplement the terms of this
+License by making exceptions from one or more of its conditions.
+Additional permissions that are applicable to the entire Program shall
+be treated as though they were included in this License, to the extent
+that they are valid under applicable law.  If additional permissions
+apply only to part of the Program, that part may be used separately
+under those permissions, but the entire Program remains governed by
+this License without regard to the additional permissions.
+
+  When you convey a copy of a covered work, you may at your option
+remove any additional permissions from that copy, or from any part of
+it.  (Additional permissions may be written to require their own
+removal in certain cases when you modify the work.)  You may place
+additional permissions on material, added by you to a covered work,
+for which you have or can give appropriate copyright permission.
+
+  Notwithstanding any other provision of this License, for material you
+add to a covered work, you may (if authorized by the copyright holders of
+that material) supplement the terms of this License with terms:
+
+    a) Disclaiming warranty or limiting liability differently from the
+    terms of sections 15 and 16 of this License; or
+
+    b) Requiring preservation of specified reasonable legal notices or
+    author attributions in that material or in the Appropriate Legal
+    Notices displayed by works containing it; or
+
+    c) Prohibiting misrepresentation of the origin of that material, or
+    requiring that modified versions of such material be marked in
+    reasonable ways as different from the original version; or
+
+    d) Limiting the use for publicity purposes of names of licensors or
+    authors of the material; or
+
+    e) Declining to grant rights under trademark law for use of some
+    trade names, trademarks, or service marks; or
+
+    f) Requiring indemnification of licensors and authors of that
+    material by anyone who conveys the material (or modified versions of
+    it) with contractual assumptions of liability to the recipient, for
+    any liability that these contractual assumptions directly impose on
+    those licensors and authors.
+
+  All other non-permissive additional terms are considered "further
+restrictions" within the meaning of section 10.  If the Program as you
+received it, or any part of it, contains a notice stating that it is
+governed by this License along with a term that is a further
+restriction, you may remove that term.  If a license document contains
+a further restriction but permits relicensing or conveying under this
+License, you may add to a covered work material governed by the terms
+of that license document, provided that the further restriction does
+not survive such relicensing or conveying.
+
+  If you add terms to a covered work in accord with this section, you
+must place, in the relevant source files, a statement of the
+additional terms that apply to those files, or a notice indicating
+where to find the applicable terms.
+
+  Additional terms, permissive or non-permissive, may be stated in the
+form of a separately written license, or stated as exceptions;
+the above requirements apply either way.
+
+  8. Termination.
+
+  You may not propagate or modify a covered work except as expressly
+provided under this License.  Any attempt otherwise to propagate or
+modify it is void, and will automatically terminate your rights under
+this License (including any patent licenses granted under the third
+paragraph of section 11).
+
+  However, if you cease all violation of this License, then your
+license from a particular copyright holder is reinstated (a)
+provisionally, unless and until the copyright holder explicitly and
+finally terminates your license, and (b) permanently, if the copyright
+holder fails to notify you of the violation by some reasonable means
+prior to 60 days after the cessation.
+
+  Moreover, your license from a particular copyright holder is
+reinstated permanently if the copyright holder notifies you of the
+violation by some reasonable means, this is the first time you have
+received notice of violation of this License (for any work) from that
+copyright holder, and you cure the violation prior to 30 days after
+your receipt of the notice.
+
+  Termination of your rights under this section does not terminate the
+licenses of parties who have received copies or rights from you under
+this License.  If your rights have been terminated and not permanently
+reinstated, you do not qualify to receive new licenses for the same
+material under section 10.
+
+  9. Acceptance Not Required for Having Copies.
+
+  You are not required to accept this License in order to receive or
+run a copy of the Program.  Ancillary propagation of a covered work
+occurring solely as a consequence of using peer-to-peer transmission
+to receive a copy likewise does not require acceptance.  However,
+nothing other than this License grants you permission to propagate or
+modify any covered work.  These actions infringe copyright if you do
+not accept this License.  Therefore, by modifying or propagating a
+covered work, you indicate your acceptance of this License to do so.
+
+  10. Automatic Licensing of Downstream Recipients.
+
+  Each time you convey a covered work, the recipient automatically
+receives a license from the original licensors, to run, modify and
+propagate that work, subject to this License.  You are not responsible
+for enforcing compliance by third parties with this License.
+
+  An "entity transaction" is a transaction transferring control of an
+organization, or substantially all assets of one, or subdividing an
+organization, or merging organizations.  If propagation of a covered
+work results from an entity transaction, each party to that
+transaction who receives a copy of the work also receives whatever
+licenses to the work the party's predecessor in interest had or could
+give under the previous paragraph, plus a right to possession of the
+Corresponding Source of the work from the predecessor in interest, if
+the predecessor has it or can get it with reasonable efforts.
+
+  You may not impose any further restrictions on the exercise of the
+rights granted or affirmed under this License.  For example, you may
+not impose a license fee, royalty, or other charge for exercise of
+rights granted under this License, and you may not initiate litigation
+(including a cross-claim or counterclaim in a lawsuit) alleging that
+any patent claim is infringed by making, using, selling, offering for
+sale, or importing the Program or any portion of it.
+
+  11. Patents.
+
+  A "contributor" is a copyright holder who authorizes use under this
+License of the Program or a work on which the Program is based.  The
+work thus licensed is called the contributor's "contributor version".
+
+  A contributor's "essential patent claims" are all patent claims
+owned or controlled by the contributor, whether already acquired or
+hereafter acquired, that would be infringed by some manner, permitted
+by this License, of making, using, or selling its contributor version,
+but do not include claims that would be infringed only as a
+consequence of further modification of the contributor version.  For
+purposes of this definition, "control" includes the right to grant
+patent sublicenses in a manner consistent with the requirements of
+this License.
+
+  Each contributor grants you a non-exclusive, worldwide, royalty-free
+patent license under the contributor's essential patent claims, to
+make, use, sell, offer for sale, import and otherwise run, modify and
+propagate the contents of its contributor version.
+
+  In the following three paragraphs, a "patent license" is any express
+agreement or commitment, however denominated, not to enforce a patent
+(such as an express permission to practice a patent or covenant not to
+sue for patent infringement).  To "grant" such a patent license to a
+party means to make such an agreement or commitment not to enforce a
+patent against the party.
+
+  If you convey a covered work, knowingly relying on a patent license,
+and the Corresponding Source of the work is not available for anyone
+to copy, free of charge and under the terms of this License, through a
+publicly available network server or other readily accessible means,
+then you must either (1) cause the Corresponding Source to be so
+available, or (2) arrange to deprive yourself of the benefit of the
+patent license for this particular work, or (3) arrange, in a manner
+consistent with the requirements of this License, to extend the patent
+license to downstream recipients.  "Knowingly relying" means you have
+actual knowledge that, but for the patent license, your conveying the
+covered work in a country, or your recipient's use of the covered work
+in a country, would infringe one or more identifiable patents in that
+country that you have reason to believe are valid.
+
+  If, pursuant to or in connection with a single transaction or
+arrangement, you convey, or propagate by procuring conveyance of, a
+covered work, and grant a patent license to some of the parties
+receiving the covered work authorizing them to use, propagate, modify
+or convey a specific copy of the covered work, then the patent license
+you grant is automatically extended to all recipients of the covered
+work and works based on it.
+
+  A patent license is "discriminatory" if it does not include within
+the scope of its coverage, prohibits the exercise of, or is
+conditioned on the non-exercise of one or more of the rights that are
+specifically granted under this License.  You may not convey a covered
+work if you are a party to an arrangement with a third party that is
+in the business of distributing software, under which you make payment
+to the third party based on the extent of your activity of conveying
+the work, and under which the third party grants, to any of the
+parties who would receive the covered work from you, a discriminatory
+patent license (a) in connection with copies of the covered work
+conveyed by you (or copies made from those copies), or (b) primarily
+for and in connection with specific products or compilations that
+contain the covered work, unless you entered into that arrangement,
+or that patent license was granted, prior to 28 March 2007.
+
+  Nothing in this License shall be construed as excluding or limiting
+any implied license or other defenses to infringement that may
+otherwise be available to you under applicable patent law.
+
+  12. No Surrender of Others' Freedom.
+
+  If conditions are imposed on you (whether by court order, agreement or
+otherwise) that contradict the conditions of this License, they do not
+excuse you from the conditions of this License.  If you cannot convey a
+covered work so as to satisfy simultaneously your obligations under this
+License and any other pertinent obligations, then as a consequence you may
+not convey it at all.  For example, if you agree to terms that obligate you
+to collect a royalty for further conveying from those to whom you convey
+the Program, the only way you could satisfy both those terms and this
+License would be to refrain entirely from conveying the Program.
+
+  13. Use with the GNU Affero General Public License.
+
+  Notwithstanding any other provision of this License, you have
+permission to link or combine any covered work with a work licensed
+under version 3 of the GNU Affero General Public License into a single
+combined work, and to convey the resulting work.  The terms of this
+License will continue to apply to the part which is the covered work,
+but the special requirements of the GNU Affero General Public License,
+section 13, concerning interaction through a network will apply to the
+combination as such.
+
+  14. Revised Versions of this License.
+
+  The Free Software Foundation may publish revised and/or new versions of
+the GNU General Public License from time to time.  Such new versions will
+be similar in spirit to the present version, but may differ in detail to
+address new problems or concerns.
+
+  Each version is given a distinguishing version number.  If the
+Program specifies that a certain numbered version of the GNU General
+Public License "or any later version" applies to it, you have the
+option of following the terms and conditions either of that numbered
+version or of any later version published by the Free Software
+Foundation.  If the Program does not specify a version number of the
+GNU General Public License, you may choose any version ever published
+by the Free Software Foundation.
+
+  If the Program specifies that a proxy can decide which future
+versions of the GNU General Public License can be used, that proxy's
+public statement of acceptance of a version permanently authorizes you
+to choose that version for the Program.
+
+  Later license versions may give you additional or different
+permissions.  However, no additional obligations are imposed on any
+author or copyright holder as a result of your choosing to follow a
+later version.
+
+  15. Disclaimer of Warranty.
+
+  THERE IS NO WARRANTY FOR THE PROGRAM, TO THE EXTENT PERMITTED BY
+APPLICABLE LAW.  EXCEPT WHEN OTHERWISE STATED IN WRITING THE COPYRIGHT
+HOLDERS AND/OR OTHER PARTIES PROVIDE THE PROGRAM "AS IS" WITHOUT WARRANTY
+OF ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING, BUT NOT LIMITED TO,
+THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+PURPOSE.  THE ENTIRE RISK AS TO THE QUALITY AND PERFORMANCE OF THE PROGRAM
+IS WITH YOU.  SHOULD THE PROGRAM PROVE DEFECTIVE, YOU ASSUME THE COST OF
+ALL NECESSARY SERVICING, REPAIR OR CORRECTION.
+
+  16. Limitation of Liability.
+
+  IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN WRITING
+WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MODIFIES AND/OR CONVEYS
+THE PROGRAM AS PERMITTED ABOVE, BE LIABLE TO YOU FOR DAMAGES, INCLUDING ANY
+GENERAL, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES ARISING OUT OF THE
+USE OR INABILITY TO USE THE PROGRAM (INCLUDING BUT NOT LIMITED TO LOSS OF
+DATA OR DATA BEING RENDERED INACCURATE OR LOSSES SUSTAINED BY YOU OR THIRD
+PARTIES OR A FAILURE OF THE PROGRAM TO OPERATE WITH ANY OTHER PROGRAMS),
+EVEN IF SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE POSSIBILITY OF
+SUCH DAMAGES.
+
+  17. Interpretation of Sections 15 and 16.
+
+  If the disclaimer of warranty and limitation of liability provided
+above cannot be given local legal effect according to their terms,
+reviewing courts shall apply local law that most closely approximates
+an absolute waiver of all civil liability in connection with the
+Program, unless a warranty or assumption of liability accompanies a
+copy of the Program in return for a fee.
+
+                     END OF TERMS AND CONDITIONS
+
+            How to Apply These Terms to Your New Programs
+
+  If you develop a new program, and you want it to be of the greatest
+possible use to the public, the best way to achieve this is to make it
+free software which everyone can redistribute and change under these terms.
+
+  To do so, attach the following notices to the program.  It is safest
+to attach them to the start of each source file to most effectively
+state the exclusion of warranty; and each file should have at least
+the "copyright" line and a pointer to where the full notice is found.
+
+    Ascently is a FOSS app meant to help climbers track their sessions, routes/problems, and overall progress.
+    Copyright (C) 2025 Atridad Lahiji
+
+    This program is free software: you can redistribute it and/or modify
+    it under the terms of the GNU General Public License as published by
+    the Free Software Foundation, either version 3 of the License, or
+    (at your option) any later version.
+
+    This program is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+    GNU General Public License for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with this program.  If not, see <https://www.gnu.org/licenses/>.
+
+Also add information on how to contact you by electronic and paper mail.
+
+  If the program does terminal interaction, make it output a short
+notice like this when it starts in an interactive mode:
+
+    Ascently  Copyright (C) 2025  Atridad Lahiji
+    This program comes with ABSOLUTELY NO WARRANTY; for details type `show w'.
+    This is free software, and you are welcome to redistribute it
+    under certain conditions; type `show c' for details.
+
+The hypothetical commands `show w' and `show c' should show the appropriate
+parts of the General Public License.  Of course, your program's commands
+might be different; for a GUI interface, you would use an "about box".
+
+  You should also get your employer (if you work as a programmer) or school,
+if any, to sign a "copyright disclaimer" for the program, if necessary.
+For more information on this, and how to apply and follow the GNU GPL, see
+<https://www.gnu.org/licenses/>.
+
+  The GNU General Public License does not permit incorporating your program
+into proprietary programs.  If your program is a subroutine library, you
+may consider it more useful to permit linking proprietary applications with
+the library.  If this is what you want to do, use the GNU Lesser General
+Public License instead of this License.  But first, please read
+<https://www.gnu.org/licenses/why-not-lgpl.html>.
--- a/android/app/build.gradle.kts
+++ b/android/app/build.gradle.kts
@@ -16,8 +16,8 @@ android {
        applicationId = "com.atridad.ascently"
        minSdk = 31
        targetSdk = 36
-        versionCode = 4
-        versionName = "2.3.0"
+        versionCode = 48
+        versionName = "2.4.0"

        testInstrumentationRunner = "androidx.test.runner.AndroidJUnitRunner"
    }
--- a/android/app/src/main/AndroidManifest.xml
+++ b/android/app/src/main/AndroidManifest.xml
@@ -27,6 +27,7 @@

    <!-- Permissions for notifications and foreground service -->
    <uses-permission android:name="android.permission.POST_NOTIFICATIONS" />
+    <uses-permission android:name="android.permission.POST_PROMOTED_NOTIFICATIONS" />
    <uses-permission android:name="android.permission.FOREGROUND_SERVICE" />
    <uses-permission android:name="android.permission.FOREGROUND_SERVICE_SPECIAL_USE" />

--- a/android/app/src/main/java/com/atridad/ascently/data/sync/AscentlySyncProvider.kt
+++ b/android/app/src/main/java/com/atridad/ascently/data/sync/AscentlySyncProvider.kt
@@ -0,0 +1,741 @@
+package com.atridad.ascently.data.sync
+
+import android.content.Context
+import android.content.SharedPreferences
+import android.net.ConnectivityManager
+import android.net.NetworkCapabilities
+import androidx.annotation.RequiresPermission
+import androidx.core.content.edit
+import com.atridad.ascently.data.format.BackupAttempt
+import com.atridad.ascently.data.format.BackupClimbSession
+import com.atridad.ascently.data.format.BackupGym
+import com.atridad.ascently.data.format.BackupProblem
+import com.atridad.ascently.data.format.ClimbDataBackup
+import com.atridad.ascently.data.repository.ClimbRepository
+import com.atridad.ascently.data.state.DataStateManager
+import com.atridad.ascently.utils.AppLogger
+import com.atridad.ascently.utils.DateFormatUtils
+import com.atridad.ascently.utils.ImageNamingUtils
+import com.atridad.ascently.utils.ImageUtils
+import java.io.IOException
+import java.text.SimpleDateFormat
+import java.util.Date
+import java.util.Locale
+import java.util.concurrent.TimeUnit
+import kotlinx.coroutines.CancellationException
+import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.flow.MutableStateFlow
+import kotlinx.coroutines.flow.StateFlow
+import kotlinx.coroutines.flow.asStateFlow
+import kotlinx.coroutines.flow.first
+import kotlinx.coroutines.withContext
+import kotlinx.serialization.json.Json
+import okhttp3.MediaType.Companion.toMediaType
+import okhttp3.OkHttpClient
+import okhttp3.Request
+import okhttp3.RequestBody.Companion.toRequestBody
+
+class AscentlySyncProvider(
+    private val context: Context,
+    private val repository: ClimbRepository
+) : SyncProvider {
+
+    override val type: SyncProviderType = SyncProviderType.SERVER
+
+    private val dataStateManager = DataStateManager(context)
+
+    companion object {
+        private const val TAG = "AscentlySyncProvider"
+    }
+
+    private val sharedPreferences: SharedPreferences =
+        context.getSharedPreferences("sync_preferences", Context.MODE_PRIVATE)
+
+    private val httpClient =
+        OkHttpClient.Builder()
+            .connectTimeout(45, TimeUnit.SECONDS)
+            .readTimeout(90, TimeUnit.SECONDS)
+            .writeTimeout(90, TimeUnit.SECONDS)
+            .build()
+
+    private val json = Json {
+        prettyPrint = true
+        ignoreUnknownKeys = true
+        explicitNulls = false
+        coerceInputValues = true
+    }
+
+    private val _isConnected = MutableStateFlow(false)
+    override val isConnected: StateFlow<Boolean> = _isConnected.asStateFlow()
+
+    private val _isConfigured = MutableStateFlow(false)
+    override val isConfigured: StateFlow<Boolean> = _isConfigured.asStateFlow()
+
+    private var isOfflineMode = false
+
+    private object Keys {
+        const val SERVER_URL = "server_url"
+        const val AUTH_TOKEN = "auth_token"
+        const val IS_CONNECTED = "is_connected"
+        const val LAST_SYNC_TIME = "last_sync_time"
+        const val OFFLINE_MODE = "offline_mode"
+    }
+
+    init {
+        loadInitialState()
+        updateConfiguredState()
+    }
+
+    private fun loadInitialState() {
+        _isConnected.value = sharedPreferences.getBoolean(Keys.IS_CONNECTED, false)
+        isOfflineMode = sharedPreferences.getBoolean(Keys.OFFLINE_MODE, false)
+    }
+
+    private fun updateConfiguredState() {
+        _isConfigured.value = serverUrl.isNotBlank() && authToken.isNotBlank()
+    }
+
+    var serverUrl: String
+        get() = sharedPreferences.getString(Keys.SERVER_URL, "") ?: ""
+        set(value) {
+            sharedPreferences.edit { putString(Keys.SERVER_URL, value) }
+            updateConfiguredState()
+            _isConnected.value = false
+            sharedPreferences.edit { putBoolean(Keys.IS_CONNECTED, false) }
+        }
+
+    var authToken: String
+        get() = sharedPreferences.getString(Keys.AUTH_TOKEN, "") ?: ""
+        set(value) {
+            sharedPreferences.edit { putString(Keys.AUTH_TOKEN, value) }
+            updateConfiguredState()
+            _isConnected.value = false
+            sharedPreferences.edit { putBoolean(Keys.IS_CONNECTED, false) }
+        }
+
+    @RequiresPermission(android.Manifest.permission.ACCESS_NETWORK_STATE)
+    private fun isNetworkAvailable(): Boolean {
+        val connectivityManager =
+            context.getSystemService(Context.CONNECTIVITY_SERVICE) as ConnectivityManager
+        val network = connectivityManager.activeNetwork ?: return false
+        val activeNetwork = connectivityManager.getNetworkCapabilities(network) ?: return false
+        return when {
+            activeNetwork.hasTransport(NetworkCapabilities.TRANSPORT_WIFI) -> true
+            activeNetwork.hasTransport(NetworkCapabilities.TRANSPORT_CELLULAR) -> true
+            else -> false
+        }
+    }
+
+    @RequiresPermission(android.Manifest.permission.ACCESS_NETWORK_STATE)
+    override suspend fun sync() {
+        if (isOfflineMode) {
+            AppLogger.d(TAG) { "Sync skipped: Offline mode is enabled." }
+            return
+        }
+        if (!isNetworkAvailable()) {
+            AppLogger.d(TAG) { "Sync skipped: No internet connection." }
+            throw SyncException.NetworkError("No internet connection.")
+        }
+        if (!_isConfigured.value) {
+            throw SyncException.NotConfigured
+        }
+        if (!_isConnected.value) {
+            throw SyncException.NotConnected
+        }
+
+        val localBackup = createBackupFromRepository()
+        val serverBackup = downloadData()
+
+        val hasLocalData =
+            localBackup.gyms.isNotEmpty() ||
+                    localBackup.problems.isNotEmpty() ||
+                    localBackup.sessions.isNotEmpty() ||
+                    localBackup.attempts.isNotEmpty()
+
+        val hasServerData =
+            serverBackup.gyms.isNotEmpty() ||
+                    serverBackup.problems.isNotEmpty() ||
+                    serverBackup.sessions.isNotEmpty() ||
+                    serverBackup.attempts.isNotEmpty()
+
+        val lastSyncTimeStr = sharedPreferences.getString(Keys.LAST_SYNC_TIME, null)
+        if (hasLocalData && hasServerData && lastSyncTimeStr != null) {
+            AppLogger.d(TAG) { "Using delta sync for incremental updates" }
+            performDeltaSync(lastSyncTimeStr)
+        } else {
+            when {
+                !hasLocalData && hasServerData -> {
+                    AppLogger.d(TAG) { "No local data found, performing full restore from server" }
+                    val imagePathMapping = syncImagesFromServer(serverBackup)
+                    importBackupToRepository(serverBackup, imagePathMapping)
+                    AppLogger.d(TAG) { "Full restore completed" }
+                }
+
+                hasLocalData && !hasServerData -> {
+                    AppLogger.d(TAG) { "No server data found, uploading local data to server" }
+                    uploadData(localBackup)
+                    syncImagesForBackup(localBackup)
+                    AppLogger.d(TAG) { "Initial upload completed" }
+                }
+
+                hasLocalData && hasServerData -> {
+                    AppLogger.d(TAG) { "Both local and server data exist, merging (server wins)" }
+                    mergeDataSafely(serverBackup)
+                    AppLogger.d(TAG) { "Merge completed" }
+                }
+
+                else -> {
+                    AppLogger.d(TAG) { "No data to sync" }
+                }
+            }
+        }
+
+        val now = DateFormatUtils.nowISO8601()
+        sharedPreferences.edit { putString(Keys.LAST_SYNC_TIME, now) }
+    }
+
+    override fun disconnect() {
+        serverUrl = ""
+        authToken = ""
+        _isConnected.value = false
+        sharedPreferences.edit {
+            remove(Keys.LAST_SYNC_TIME)
+            putBoolean(Keys.IS_CONNECTED, false)
+        }
+        updateConfiguredState()
+    }
+
+    private suspend fun performDeltaSync(lastSyncTimeStr: String) {
+        AppLogger.d(TAG) { "Starting delta sync with lastSyncTime=$lastSyncTimeStr" }
+
+        val lastSyncDate = parseISO8601(lastSyncTimeStr) ?: Date(0)
+
+        val allGyms = repository.getAllGyms().first()
+        val modifiedGyms =
+            allGyms
+                .filter { gym -> parseISO8601(gym.updatedAt)?.after(lastSyncDate) == true }
+                .map { BackupGym.fromGym(it) }
+
+        val allProblems = repository.getAllProblems().first()
+        val modifiedProblems =
+            allProblems
+                .filter { problem ->
+                    parseISO8601(problem.updatedAt)?.after(lastSyncDate) == true
+                }
+                .map { problem ->
+                    val backupProblem = BackupProblem.fromProblem(problem)
+                    val normalizedImagePaths =
+                        problem.imagePaths.mapIndexed { index, _ ->
+                            ImageNamingUtils.generateImageFilename(problem.id, index)
+                        }
+                    if (normalizedImagePaths.isNotEmpty()) {
+                        backupProblem.copy(imagePaths = normalizedImagePaths)
+                    } else {
+                        backupProblem
+                    }
+                }
+
+        val allSessions = repository.getAllSessions().first()
+        val modifiedSessions =
+            allSessions
+                .filter { session ->
+                    parseISO8601(session.updatedAt)?.after(lastSyncDate) == true
+                }
+                .map { BackupClimbSession.fromClimbSession(it) }
+
+        val allAttempts = repository.getAllAttempts().first()
+        val modifiedAttempts =
+            allAttempts
+                .filter { attempt ->
+                    parseISO8601(attempt.createdAt)?.after(lastSyncDate) == true
+                }
+                .map { BackupAttempt.fromAttempt(it) }
+
+        val allDeletions = repository.getDeletedItems()
+        val modifiedDeletions =
+            allDeletions.filter { item ->
+                parseISO8601(item.deletedAt)?.after(lastSyncDate) == true
+            }
+
+        AppLogger.d(TAG) {
+            "Delta sync sending: gyms=${modifiedGyms.size}, problems=${modifiedProblems.size}, sessions=${modifiedSessions.size}, attempts=${modifiedAttempts.size}, deletions=${modifiedDeletions.size}"
+        }
+
+        val deltaRequest =
+            DeltaSyncRequest(
+                lastSyncTime = lastSyncTimeStr,
+                gyms = modifiedGyms,
+                problems = modifiedProblems,
+                sessions = modifiedSessions,
+                attempts = modifiedAttempts,
+                deletedItems = modifiedDeletions
+            )
+
+        val requestBody =
+            json.encodeToString(DeltaSyncRequest.serializer(), deltaRequest)
+                .toRequestBody("application/json".toMediaType())
+
+        val request =
+            Request.Builder()
+                .url("$serverUrl/sync/delta")
+                .header("Authorization", "Bearer $authToken")
+                .post(requestBody)
+                .build()
+
+        val deltaResponse =
+            withContext(Dispatchers.IO) {
+                try {
+                    httpClient.newCall(request).execute().use { response ->
+                        if (response.isSuccessful) {
+                            val body = response.body?.string()
+                            if (!body.isNullOrEmpty()) {
+                                json.decodeFromString(DeltaSyncResponse.serializer(), body)
+                            } else {
+                                throw SyncException.InvalidResponse("Empty response body")
+                            }
+                        } else {
+                            handleHttpError(response.code)
+                        }
+                    }
+                } catch (e: IOException) {
+                    throw SyncException.NetworkError(e.message ?: "Network error")
+                }
+            }
+
+        AppLogger.d(TAG) {
+            "Delta sync received: gyms=${deltaResponse.gyms.size}, problems=${deltaResponse.problems.size}, sessions=${deltaResponse.sessions.size}, attempts=${deltaResponse.attempts.size}, deletions=${deltaResponse.deletedItems.size}"
+        }
+
+        applyDeltaResponse(deltaResponse)
+        syncModifiedImages(modifiedProblems)
+    }
+
+    private fun parseISO8601(dateString: String): Date? {
+        return try {
+            val format = SimpleDateFormat("yyyy-MM-dd'T'HH:mm:ss", Locale.US)
+            format.parse(dateString)
+        } catch (_: Exception) {
+            null
+        }
+    }
+
+    private suspend fun applyDeltaResponse(response: DeltaSyncResponse) {
+        // SyncService handles the "isSyncing" state to prevent recursive sync triggers
+        // when the repository is modified during a sync operation.
+
+        try {
+            // Merge and apply deletions first to prevent resurrection
+            val allDeletions = repository.getDeletedItems() + response.deletedItems
+            val uniqueDeletions = allDeletions.distinctBy { "${it.type}:${it.id}" }
+
+            AppLogger.d(TAG) { "Applying ${uniqueDeletions.size} deletion records before merging data" }
+            applyDeletions(uniqueDeletions)
+
+            // Build deleted item lookup set
+            val deletedItemSet = uniqueDeletions.map { "${it.type}:${it.id}" }.toSet()
+
+            // Download images for new/modified problems from server
+            val imagePathMapping = mutableMapOf<String, String>()
+            for (problem in response.problems) {
+                if (deletedItemSet.contains("problem:${problem.id}")) {
+                    continue
+                }
+                problem.imagePaths?.forEach { imagePath ->
+                    val serverFilename = imagePath.substringAfterLast('/')
+                    try {
+                        val localImagePath = downloadImage(serverFilename)
+                        if (localImagePath != null) {
+                            imagePathMapping[imagePath] = localImagePath
+                        }
+                    } catch (e: Exception) {
+                        AppLogger.w(TAG) { "Failed to download image $imagePath: ${e.message}" }
+                    }
+                }
+            }
+
+            // Merge gyms
+            val existingGyms = repository.getAllGyms().first()
+            for (backupGym in response.gyms) {
+                if (deletedItemSet.contains("gym:${backupGym.id}")) {
+                    continue
+                }
+                val existing = existingGyms.find { it.id == backupGym.id }
+                if (existing == null || backupGym.updatedAt >= existing.updatedAt) {
+                    val gym = backupGym.toGym()
+                    if (existing != null) {
+                        repository.updateGym(gym)
+                    } else {
+                        repository.insertGym(gym)
+                    }
+                }
+            }
+
+            // Merge problems
+            val existingProblems = repository.getAllProblems().first()
+            for (backupProblem in response.problems) {
+                if (deletedItemSet.contains("problem:${backupProblem.id}")) {
+                    continue
+                }
+                val updatedImagePaths =
+                    backupProblem.imagePaths?.map { oldPath ->
+                        imagePathMapping[oldPath] ?: oldPath
+                    }
+                val problemToMerge = backupProblem.copy(imagePaths = updatedImagePaths)
+                val problem = problemToMerge.toProblem()
+
+                val existing = existingProblems.find { it.id == backupProblem.id }
+                if (existing == null || backupProblem.updatedAt >= existing.updatedAt) {
+                    if (existing != null) {
+                        repository.updateProblem(problem)
+                    } else {
+                        repository.insertProblem(problem)
+                    }
+                }
+            }
+
+            // Merge sessions
+            val existingSessions = repository.getAllSessions().first()
+            for (backupSession in response.sessions) {
+                if (deletedItemSet.contains("session:${backupSession.id}")) {
+                    continue
+                }
+                val session = backupSession.toClimbSession()
+                val existing = existingSessions.find { it.id == backupSession.id }
+                if (existing == null || backupSession.updatedAt >= existing.updatedAt) {
+                    if (existing != null) {
+                        repository.updateSession(session)
+                    } else {
+                        repository.insertSession(session)
+                    }
+                }
+            }
+
+            // Merge attempts
+            val existingAttempts = repository.getAllAttempts().first()
+            for (backupAttempt in response.attempts) {
+                if (deletedItemSet.contains("attempt:${backupAttempt.id}")) {
+                    continue
+                }
+                val attempt = backupAttempt.toAttempt()
+                val existing = existingAttempts.find { it.id == backupAttempt.id }
+                if (existing == null || backupAttempt.createdAt >= existing.createdAt) {
+                    if (existing != null) {
+                        repository.updateAttempt(attempt)
+                    } else {
+                        repository.insertAttempt(attempt)
+                    }
+                }
+            }
+
+            // Apply deletions again for safety
+            applyDeletions(uniqueDeletions)
+
+            // Update deletion records
+            repository.clearDeletedItems()
+            uniqueDeletions.forEach { repository.trackDeletion(it.id, it.type) }
+        } catch (e: Exception) {
+            AppLogger.e(TAG, e) { "Error applying delta response" }
+            throw e
+        }
+    }
+
+    private suspend fun applyDeletions(
+        deletions: List<com.atridad.ascently.data.format.DeletedItem>
+    ) {
+        val existingGyms = repository.getAllGyms().first()
+        val existingProblems = repository.getAllProblems().first()
+        val existingSessions = repository.getAllSessions().first()
+        val existingAttempts = repository.getAllAttempts().first()
+
+        for (item in deletions) {
+            when (item.type) {
+                "gym" -> {
+                    existingGyms.find { it.id == item.id }?.let { repository.deleteGym(it) }
+                }
+
+                "problem" -> {
+                    existingProblems.find { it.id == item.id }?.let { repository.deleteProblem(it) }
+                }
+
+                "session" -> {
+                    existingSessions.find { it.id == item.id }?.let { repository.deleteSession(it) }
+                }
+
+                "attempt" -> {
+                    existingAttempts.find { it.id == item.id }?.let { repository.deleteAttempt(it) }
+                }
+            }
+        }
+    }
+
+    private suspend fun syncModifiedImages(modifiedProblems: List<BackupProblem>) {
+        if (modifiedProblems.isEmpty()) return
+
+        AppLogger.d(TAG) { "Syncing images for ${modifiedProblems.size} modified problems" }
+
+        for (backupProblem in modifiedProblems) {
+            backupProblem.imagePaths?.forEach { imagePath ->
+                val filename = imagePath.substringAfterLast('/')
+                uploadImage(imagePath, filename)
+            }
+        }
+    }
+
+    private suspend fun downloadData(): ClimbDataBackup {
+        val request =
+            Request.Builder()
+                .url("$serverUrl/sync")
+                .header("Authorization", "Bearer $authToken")
+                .get()
+                .build()
+
+        return withContext(Dispatchers.IO) {
+            try {
+                httpClient.newCall(request).execute().use { response ->
+                    if (response.isSuccessful) {
+                        val body = response.body?.string()
+                        if (!body.isNullOrEmpty()) {
+                            json.decodeFromString(body)
+                        } else {
+                            ClimbDataBackup(
+                                exportedAt = DateFormatUtils.nowISO8601(),
+                                gyms = emptyList(),
+                                problems = emptyList(),
+                                sessions = emptyList(),
+                                attempts = emptyList()
+                            )
+                        }
+                    } else {
+                        handleHttpError(response.code)
+                    }
+                }
+            } catch (e: IOException) {
+                throw SyncException.NetworkError(e.message ?: "Network error")
+            }
+        }
+    }
+
+    private suspend fun uploadData(backup: ClimbDataBackup) {
+        val requestBody =
+            json.encodeToString(backup).toRequestBody("application/json".toMediaType())
+
+        val request =
+            Request.Builder()
+                .url("$serverUrl/sync")
+                .header("Authorization", "Bearer $authToken")
+                .put(requestBody)
+                .build()
+
+        withContext(Dispatchers.IO) {
+            try {
+                httpClient.newCall(request).execute().use { response ->
+                    if (!response.isSuccessful) {
+                        handleHttpError(response.code)
+                    }
+                }
+            } catch (e: IOException) {
+                throw SyncException.NetworkError(e.message ?: "Network error")
+            }
+        }
+    }
+
+    private suspend fun syncImagesFromServer(backup: ClimbDataBackup): Map<String, String> {
+        val imagePathMapping = mutableMapOf<String, String>()
+        val totalImages = backup.problems.sumOf { it.imagePaths?.size ?: 0 }
+        AppLogger.d(TAG) { "Starting image download from server for $totalImages images" }
+
+        withContext(Dispatchers.IO) {
+            backup.problems.forEach { problem ->
+                problem.imagePaths?.forEach { imagePath ->
+                    val serverFilename = imagePath.substringAfterLast('/')
+                    try {
+                        val localImagePath = downloadImage(serverFilename)
+                        if (localImagePath != null) {
+                            imagePathMapping[imagePath] = localImagePath
+                        }
+                    } catch (_: SyncException.ImageNotFound) {
+                        AppLogger.w(TAG) { "Image not found on server: $imagePath" }
+                    } catch (e: CancellationException) {
+                        throw e
+                    } catch (e: Exception) {
+                        AppLogger.w(TAG) { "Failed to download image $imagePath: ${e.message}" }
+                    }
+                }
+            }
+        }
+        return imagePathMapping
+    }
+
+    private suspend fun downloadImage(serverFilename: String): String? {
+        val request =
+            Request.Builder()
+                .url("$serverUrl/images/download?filename=$serverFilename")
+                .header("Authorization", "Bearer $authToken")
+                .build()
+
+        return withContext(Dispatchers.IO) {
+            try {
+                httpClient.newCall(request).execute().use { response ->
+                    if (response.isSuccessful) {
+                        response.body?.bytes()?.let {
+                            ImageUtils.saveImageFromBytesWithFilename(context, it, serverFilename)
+                        }
+                    } else {
+                        if (response.code == 404) throw SyncException.ImageNotFound
+                        null
+                    }
+                }
+            } catch (e: IOException) {
+                AppLogger.e(TAG, e) { "Network error downloading image $serverFilename" }
+                null
+            }
+        }
+    }
+
+    private suspend fun syncImagesForBackup(backup: ClimbDataBackup) {
+        AppLogger.d(TAG) { "Starting image sync for backup with ${backup.problems.size} problems" }
+        withContext(Dispatchers.IO) {
+            backup.problems.forEach { problem ->
+                problem.imagePaths?.forEach { localPath ->
+                    val filename = localPath.substringAfterLast('/')
+                    uploadImage(localPath, filename)
+                }
+            }
+        }
+    }
+
+    private suspend fun uploadImage(localPath: String, filename: String) {
+        val file = ImageUtils.getImageFile(context, localPath)
+        if (!file.exists()) {
+            AppLogger.w(TAG) { "Local image file not found, cannot upload: $localPath" }
+            return
+        }
+
+        val requestBody = file.readBytes().toRequestBody("application/octet-stream".toMediaType())
+
+        val request =
+            Request.Builder()
+                .url("$serverUrl/images/upload?filename=$filename")
+                .header("Authorization", "Bearer $authToken")
+                .post(requestBody)
+                .build()
+
+        withContext(Dispatchers.IO) {
+            try {
+                httpClient.newCall(request).execute().use { response ->
+                    if (response.isSuccessful) {
+                        AppLogger.d(TAG) { "Successfully uploaded image: $filename" }
+                    } else {
+                        AppLogger.w(TAG) {
+                            "Failed to upload image $filename. Server responded with ${response.code}"
+                        }
+                    }
+                }
+            } catch (e: IOException) {
+                AppLogger.e(TAG, e) { "Network error uploading image $filename" }
+            }
+        }
+    }
+
+    private suspend fun createBackupFromRepository(): ClimbDataBackup {
+        return withContext(Dispatchers.Default) {
+            ClimbDataBackup(
+                exportedAt = dataStateManager.getLastModified(),
+                gyms = repository.getAllGyms().first().map { BackupGym.fromGym(it) },
+                problems =
+                    repository.getAllProblems().first().map { problem ->
+                        val backupProblem = BackupProblem.fromProblem(problem)
+                        val normalizedImagePaths =
+                            problem.imagePaths.mapIndexed { index, _ ->
+                                ImageNamingUtils.generateImageFilename(
+                                    problem.id,
+                                    index
+                                )
+                            }
+                        if (normalizedImagePaths.isNotEmpty()) {
+                            backupProblem.copy(imagePaths = normalizedImagePaths)
+                        } else {
+                            backupProblem
+                        }
+                    },
+                sessions =
+                    repository.getAllSessions().first().map {
+                        BackupClimbSession.fromClimbSession(it)
+                    },
+                attempts =
+                    repository.getAllAttempts().first().map {
+                        BackupAttempt.fromAttempt(it)
+                    },
+                deletedItems = repository.getDeletedItems()
+            )
+        }
+    }
+
+    private suspend fun importBackupToRepository(
+        backup: ClimbDataBackup,
+        imagePathMapping: Map<String, String>
+    ) {
+        val gyms = backup.gyms.map { it.toGym() }
+        val problems =
+            backup.problems.map { backupProblem ->
+                val imagePaths = backupProblem.imagePaths
+                val updatedImagePaths =
+                    imagePaths?.map { oldPath -> imagePathMapping[oldPath] ?: oldPath }
+                backupProblem.copy(imagePaths = updatedImagePaths).toProblem()
+            }
+        val sessions = backup.sessions.map { it.toClimbSession() }
+        val attempts = backup.attempts.map { it.toAttempt() }
+
+        repository.resetAllData()
+
+        gyms.forEach { repository.insertGymWithoutSync(it) }
+        problems.forEach { repository.insertProblemWithoutSync(it) }
+        sessions.forEach { repository.insertSessionWithoutSync(it) }
+        attempts.forEach { repository.insertAttemptWithoutSync(it) }
+
+        repository.clearDeletedItems()
+    }
+
+    private suspend fun mergeDataSafely(serverBackup: ClimbDataBackup) {
+        AppLogger.d(TAG) { "Server data will overwrite local data. Performing full restore." }
+        val imagePathMapping = syncImagesFromServer(serverBackup)
+        importBackupToRepository(serverBackup, imagePathMapping)
+    }
+
+    private fun handleHttpError(code: Int): Nothing {
+        when (code) {
+            401 -> throw SyncException.Unauthorized
+            in 500..599 -> throw SyncException.ServerError(code)
+            else -> throw SyncException.InvalidResponse("HTTP error code: $code")
+        }
+    }
+
+    override suspend fun testConnection() {
+        if (!_isConfigured.value) {
+            _isConnected.value = false
+            throw SyncException.NotConfigured
+        }
+
+        val request =
+            Request.Builder()
+                .url("$serverUrl/sync")
+                .header("Authorization", "Bearer $authToken")
+                .head()
+                .build()
+        try {
+            withContext(Dispatchers.IO) {
+                httpClient.newCall(request).execute().use { response ->
+                    _isConnected.value = response.isSuccessful || response.code == 405
+                }
+            }
+            if (!_isConnected.value) {
+                throw SyncException.NotConnected
+            }
+        } catch (e: Exception) {
+            _isConnected.value = false
+            throw SyncException.NetworkError(e.message ?: "Connection error")
+        } finally {
+            sharedPreferences.edit { putBoolean(Keys.IS_CONNECTED, _isConnected.value) }
+        }
+    }
+}
--- a/android/app/src/main/java/com/atridad/ascently/data/sync/SyncException.kt
+++ b/android/app/src/main/java/com/atridad/ascently/data/sync/SyncException.kt
@@ -0,0 +1,21 @@
+package com.atridad.ascently.data.sync
+
+import java.io.IOException
+import java.io.Serializable
+
+sealed class SyncException(message: String) : IOException(message), Serializable {
+    object NotConfigured :
+        SyncException("Sync is not configured. Please set server URL and auth token.")
+
+    object NotConnected : SyncException("Not connected to server. Please test connection first.")
+
+    object Unauthorized : SyncException("Unauthorized. Please check your auth token.")
+
+    object ImageNotFound : SyncException("Image not found on server")
+
+    data class ServerError(val code: Int) : SyncException("Server error: HTTP $code")
+    data class InvalidResponse(val details: String) :
+        SyncException("Invalid server response: $details")
+
+    data class NetworkError(val details: String) : SyncException("Network error: $details")
+}
--- a/android/app/src/main/java/com/atridad/ascently/data/sync/SyncProvider.kt
+++ b/android/app/src/main/java/com/atridad/ascently/data/sync/SyncProvider.kt
@@ -0,0 +1,18 @@
+package com.atridad.ascently.data.sync
+
+import kotlinx.coroutines.flow.StateFlow
+
+interface SyncProvider {
+    val type: SyncProviderType
+    val isConfigured: StateFlow<Boolean>
+    val isConnected: StateFlow<Boolean>
+    
+    suspend fun sync()
+    suspend fun testConnection()
+    fun disconnect()
+}
+
+enum class SyncProviderType {
+    NONE,
+    SERVER
+}
--- a/android/app/src/main/java/com/atridad/ascently/data/sync/SyncService.kt
+++ b/android/app/src/main/java/com/atridad/ascently/data/sync/SyncService.kt
@@ -2,27 +2,9 @@ package com.atridad.ascently.data.sync

 import android.content.Context
 import android.content.SharedPreferences
-import android.net.ConnectivityManager
-import android.net.NetworkCapabilities
-import androidx.annotation.RequiresPermission
 import androidx.core.content.edit
-import com.atridad.ascently.data.format.BackupAttempt
-import com.atridad.ascently.utils.AppLogger
-import com.atridad.ascently.data.format.BackupClimbSession
-import com.atridad.ascently.data.format.BackupGym
-import com.atridad.ascently.data.format.BackupProblem
-import com.atridad.ascently.data.format.ClimbDataBackup
 import com.atridad.ascently.data.repository.ClimbRepository
-import com.atridad.ascently.data.state.DataStateManager
-import com.atridad.ascently.utils.DateFormatUtils
-import com.atridad.ascently.utils.ImageNamingUtils
-import com.atridad.ascently.utils.ImageUtils
-import java.io.IOException
-import java.io.Serializable
-import java.text.SimpleDateFormat
-import java.util.Date
-import java.util.Locale
-import java.util.concurrent.TimeUnit
+import com.atridad.ascently.utils.AppLogger
 import kotlinx.coroutines.CoroutineScope
 import kotlinx.coroutines.Dispatchers
 import kotlinx.coroutines.Job
@@ -31,43 +13,21 @@ import kotlinx.coroutines.delay
 import kotlinx.coroutines.flow.MutableStateFlow
 import kotlinx.coroutines.flow.StateFlow
 import kotlinx.coroutines.flow.asStateFlow
-import kotlinx.coroutines.flow.first
 import kotlinx.coroutines.launch
 import kotlinx.coroutines.sync.Mutex
 import kotlinx.coroutines.sync.withLock
-import kotlinx.coroutines.withContext
-import kotlinx.serialization.json.Json
-import okhttp3.MediaType.Companion.toMediaType
-import okhttp3.OkHttpClient
-import okhttp3.Request
-import okhttp3.RequestBody.Companion.toRequestBody

 class SyncService(private val context: Context, private val repository: ClimbRepository) {

-    private val dataStateManager = DataStateManager(context)
-    private val syncMutex = Mutex()
    private val serviceScope = CoroutineScope(Dispatchers.IO + SupervisorJob())
+    private val syncMutex = Mutex()

    companion object {
        private const val TAG = "SyncService"
    }

-    private val sharedPreferences: SharedPreferences =
-        context.getSharedPreferences("sync_preferences", Context.MODE_PRIVATE)
-
-    private val httpClient =
-        OkHttpClient.Builder()
-            .connectTimeout(45, TimeUnit.SECONDS)
-            .readTimeout(90, TimeUnit.SECONDS)
-            .writeTimeout(90, TimeUnit.SECONDS)
-            .build()
-
-    private val json = Json {
-        prettyPrint = true
-        ignoreUnknownKeys = true
-        explicitNulls = false
-        coerceInputValues = true
-    }
+    // Currently we only support one provider, but this allows for future expansion
+    private val provider: SyncProvider = AscentlySyncProvider(context, repository)

    // State
    private val _isSyncing = MutableStateFlow(false)
@@ -79,11 +39,9 @@ class SyncService(private val context: Context, private val repository: ClimbRep
    private val _syncError = MutableStateFlow<String?>(null)
    val syncError: StateFlow<String?> = _syncError.asStateFlow()

-    private val _isConnected = MutableStateFlow(false)
-    val isConnected: StateFlow<Boolean> = _isConnected.asStateFlow()
-
-    private val _isConfigured = MutableStateFlow(false)
-    val isConfiguredFlow: StateFlow<Boolean> = _isConfigured.asStateFlow()
+    // Delegate to provider
+    val isConnected: StateFlow<Boolean> = provider.isConnected
+    val isConfiguredFlow: StateFlow<Boolean> = provider.isConfigured

    private val _isTesting = MutableStateFlow(false)
    val isTesting: StateFlow<Boolean> = _isTesting.asStateFlow()
@@ -91,56 +49,40 @@ class SyncService(private val context: Context, private val repository: ClimbRep
    private val _isAutoSyncEnabled = MutableStateFlow(true)
    val isAutoSyncEnabled: StateFlow<Boolean> = _isAutoSyncEnabled.asStateFlow()

-    private var isOfflineMode = false
-
    // Debounced sync properties
    private var syncJob: Job? = null
    private var pendingChanges = false
    private val syncDebounceDelay = 2000L // 2 seconds

-    // Configuration keys
+    private val sharedPreferences: SharedPreferences =
+        context.getSharedPreferences("sync_preferences", Context.MODE_PRIVATE)
+
    private object Keys {
-        const val SERVER_URL = "server_url"
-        const val AUTH_TOKEN = "auth_token"
-        const val IS_CONNECTED = "is_connected"
        const val LAST_SYNC_TIME = "last_sync_time"
        const val AUTO_SYNC_ENABLED = "auto_sync_enabled"
-        const val OFFLINE_MODE = "offline_mode"
    }

    init {
        loadInitialState()
-        updateConfiguredState()
        repository.setAutoSyncCallback { serviceScope.launch { triggerAutoSync() } }
    }

    private fun loadInitialState() {
        _lastSyncTime.value = sharedPreferences.getString(Keys.LAST_SYNC_TIME, null)
-        _isConnected.value = sharedPreferences.getBoolean(Keys.IS_CONNECTED, false)
        _isAutoSyncEnabled.value = sharedPreferences.getBoolean(Keys.AUTO_SYNC_ENABLED, true)
-        isOfflineMode = sharedPreferences.getBoolean(Keys.OFFLINE_MODE, false)
-    }
-
-    private fun updateConfiguredState() {
-        _isConfigured.value = serverUrl.isNotBlank() && authToken.isNotBlank()
    }

+    // Proxy properties for Ascently provider configuration
    var serverUrl: String
-        get() = sharedPreferences.getString(Keys.SERVER_URL, "") ?: ""
+        get() = (provider as? AscentlySyncProvider)?.serverUrl ?: ""
        set(value) {
-            sharedPreferences.edit { putString(Keys.SERVER_URL, value) }
-            updateConfiguredState()
-            _isConnected.value = false
-            sharedPreferences.edit { putBoolean(Keys.IS_CONNECTED, false) }
+            (provider as? AscentlySyncProvider)?.serverUrl = value
        }

    var authToken: String
-        get() = sharedPreferences.getString(Keys.AUTH_TOKEN, "") ?: ""
+        get() = (provider as? AscentlySyncProvider)?.authToken ?: ""
        set(value) {
-            sharedPreferences.edit { putString(Keys.AUTH_TOKEN, value) }
-            updateConfiguredState()
-            _isConnected.value = false
-            sharedPreferences.edit { putBoolean(Keys.IS_CONNECTED, false) }
+            (provider as? AscentlySyncProvider)?.authToken = value
        }

    fun setAutoSyncEnabled(enabled: Boolean) {
@@ -148,93 +90,21 @@ class SyncService(private val context: Context, private val repository: ClimbRep
        sharedPreferences.edit { putBoolean(Keys.AUTO_SYNC_ENABLED, enabled) }
    }

-    @RequiresPermission(android.Manifest.permission.ACCESS_NETWORK_STATE)
-    private fun isNetworkAvailable(): Boolean {
-        val connectivityManager =
-            context.getSystemService(Context.CONNECTIVITY_SERVICE) as ConnectivityManager
-        val network = connectivityManager.activeNetwork ?: return false
-        val activeNetwork = connectivityManager.getNetworkCapabilities(network) ?: return false
-        return when {
-            activeNetwork.hasTransport(NetworkCapabilities.TRANSPORT_WIFI) -> true
-            activeNetwork.hasTransport(NetworkCapabilities.TRANSPORT_CELLULAR) -> true
-            else -> false
-        }
-    }
-
-    @RequiresPermission(android.Manifest.permission.ACCESS_NETWORK_STATE)
    suspend fun syncWithServer() {
-        if (isOfflineMode) {
-            AppLogger.d(TAG) { "Sync skipped: Offline mode is enabled." }
-            return
-        }
-        if (!isNetworkAvailable()) {
-            _syncError.value = "No internet connection."
-            AppLogger.d(TAG) { "Sync skipped: No internet connection." }
-            return
-        }
-        if (!_isConfigured.value) {
+        if (!isConfiguredFlow.value) {
            throw SyncException.NotConfigured
        }
-        if (!_isConnected.value) {
-            throw SyncException.NotConnected
-        }

        syncMutex.withLock {
            _isSyncing.value = true
            _syncError.value = null

            try {
-                val localBackup = createBackupFromRepository()
-                val serverBackup = downloadData()
-
-                val hasLocalData =
-                    localBackup.gyms.isNotEmpty() ||
-                            localBackup.problems.isNotEmpty() ||
-                            localBackup.sessions.isNotEmpty() ||
-                            localBackup.attempts.isNotEmpty()
-
-                val hasServerData =
-                    serverBackup.gyms.isNotEmpty() ||
-                            serverBackup.problems.isNotEmpty() ||
-                            serverBackup.sessions.isNotEmpty() ||
-                            serverBackup.attempts.isNotEmpty()
-
-                // If both client and server have been synced before, use delta sync
-                val lastSyncTimeStr = sharedPreferences.getString(Keys.LAST_SYNC_TIME, null)
-                if (hasLocalData && hasServerData && lastSyncTimeStr != null) {
-                    AppLogger.d(TAG) { "Using delta sync for incremental updates" }
-                    performDeltaSync(lastSyncTimeStr)
-                } else {
-                    when {
-                        !hasLocalData && hasServerData -> {
-                            AppLogger.d(TAG) { "No local data found, performing full restore from server" }
-                            val imagePathMapping = syncImagesFromServer(serverBackup)
-                            importBackupToRepository(serverBackup, imagePathMapping)
-                            AppLogger.d(TAG) { "Full restore completed" }
-                        }
-
-                        hasLocalData && !hasServerData -> {
-                            AppLogger.d(TAG) { "No server data found, uploading local data to server" }
-                            uploadData(localBackup)
-                            syncImagesForBackup(localBackup)
-                            AppLogger.d(TAG) { "Initial upload completed" }
-                        }
-
-                        hasLocalData && hasServerData -> {
-                            AppLogger.d(TAG) { "Both local and server data exist, merging (server wins)" }
-                            mergeDataSafely(serverBackup)
-                            AppLogger.d(TAG) { "Merge completed" }
-                        }
-
-                        else -> {
-                            AppLogger.d(TAG) { "No data to sync" }
-                        }
-                    }
-                }
-
-                val now = DateFormatUtils.nowISO8601()
-                _lastSyncTime.value = now
-                sharedPreferences.edit { putString(Keys.LAST_SYNC_TIME, now) }
+                provider.sync()
+                
+                // Update last sync time from shared prefs (provider updates it)
+                _lastSyncTime.value = sharedPreferences.getString(Keys.LAST_SYNC_TIME, null)
+                
            } catch (e: Exception) {
                _syncError.value = e.message
                throw e
@@ -244,550 +114,21 @@ class SyncService(private val context: Context, private val repository: ClimbRep
        }
    }

-    private suspend fun performDeltaSync(lastSyncTimeStr: String) {
-        AppLogger.d(TAG) { "Starting delta sync with lastSyncTime=$lastSyncTimeStr" }
-
-        // Parse last sync time to filter modified items
-        val lastSyncDate = parseISO8601(lastSyncTimeStr) ?: Date(0)
-
-        // Collect items modified since last sync
-        val allGyms = repository.getAllGyms().first()
-        val modifiedGyms =
-            allGyms
-                .filter { gym -> parseISO8601(gym.updatedAt)?.after(lastSyncDate) == true }
-                .map { BackupGym.fromGym(it) }
-
-        val allProblems = repository.getAllProblems().first()
-        val modifiedProblems =
-            allProblems
-                .filter { problem ->
-                    parseISO8601(problem.updatedAt)?.after(lastSyncDate) == true
-                }
-                .map { problem ->
-                    val backupProblem = BackupProblem.fromProblem(problem)
-                    val normalizedImagePaths =
-                        problem.imagePaths.mapIndexed { index, _ ->
-                            ImageNamingUtils.generateImageFilename(problem.id, index)
-                        }
-                    if (normalizedImagePaths.isNotEmpty()) {
-                        backupProblem.copy(imagePaths = normalizedImagePaths)
-                    } else {
-                        backupProblem
-                    }
-                }
-
-        val allSessions = repository.getAllSessions().first()
-        val modifiedSessions =
-            allSessions
-                .filter { session ->
-                    parseISO8601(session.updatedAt)?.after(lastSyncDate) == true
-                }
-                .map { BackupClimbSession.fromClimbSession(it) }
-
-        val allAttempts = repository.getAllAttempts().first()
-        val modifiedAttempts =
-            allAttempts
-                .filter { attempt ->
-                    parseISO8601(attempt.createdAt)?.after(lastSyncDate) == true
-                }
-                .map { BackupAttempt.fromAttempt(it) }
-
-        val allDeletions = repository.getDeletedItems()
-        val modifiedDeletions =
-            allDeletions.filter { item ->
-                parseISO8601(item.deletedAt)?.after(lastSyncDate) == true
-            }
-
-        AppLogger.d(TAG) {
-            "Delta sync sending: gyms=${modifiedGyms.size}, problems=${modifiedProblems.size}, sessions=${modifiedSessions.size}, attempts=${modifiedAttempts.size}, deletions=${modifiedDeletions.size}"
-        }
-
-        // Create delta request
-        val deltaRequest =
-            DeltaSyncRequest(
-                lastSyncTime = lastSyncTimeStr,
-                gyms = modifiedGyms,
-                problems = modifiedProblems,
-                sessions = modifiedSessions,
-                attempts = modifiedAttempts,
-                deletedItems = modifiedDeletions
-            )
-
-        val requestBody =
-            json.encodeToString(DeltaSyncRequest.serializer(), deltaRequest)
-                .toRequestBody("application/json".toMediaType())
-
-        val request =
-            Request.Builder()
-                .url("$serverUrl/sync/delta")
-                .header("Authorization", "Bearer $authToken")
-                .post(requestBody)
-                .build()
-
-        val deltaResponse =
-            withContext(Dispatchers.IO) {
-                try {
-                    httpClient.newCall(request).execute().use { response ->
-                        if (response.isSuccessful) {
-                            val body = response.body?.string()
-                            if (!body.isNullOrEmpty()) {
-                                json.decodeFromString(DeltaSyncResponse.serializer(), body)
-                            } else {
-                                throw SyncException.InvalidResponse("Empty response body")
-                            }
-                        } else {
-                            handleHttpError(response.code)
-                        }
-                    }
-                } catch (e: IOException) {
-                    throw SyncException.NetworkError(e.message ?: "Network error")
-                }
-            }
-
-        AppLogger.d(TAG) {
-            "Delta sync received: gyms=${deltaResponse.gyms.size}, problems=${deltaResponse.problems.size}, sessions=${deltaResponse.sessions.size}, attempts=${deltaResponse.attempts.size}, deletions=${deltaResponse.deletedItems.size}"
-        }
-
-        // Apply server changes to local data
-        applyDeltaResponse(deltaResponse)
-
-        // Sync only modified problem images
-        syncModifiedImages(modifiedProblems)
-    }
-
-    private fun parseISO8601(dateString: String): Date? {
-        return try {
-            val format = SimpleDateFormat("yyyy-MM-dd'T'HH:mm:ss", Locale.US)
-            format.parse(dateString)
-        } catch (e: Exception) {
-            null
-        }
-    }
-
-    private suspend fun applyDeltaResponse(response: DeltaSyncResponse) {
-        // Temporarily disable auto-sync to prevent recursive sync triggers
-        repository.setAutoSyncCallback(null)
-
-        try {
-            // Merge and apply deletions first to prevent resurrection
-            val allDeletions = repository.getDeletedItems() + response.deletedItems
-            val uniqueDeletions = allDeletions.distinctBy { "${it.type}:${it.id}" }
-
-            AppLogger.d(TAG) { "Applying ${uniqueDeletions.size} deletion records before merging data" }
-            applyDeletions(uniqueDeletions)
-
-            // Build deleted item lookup set
-            val deletedItemSet = uniqueDeletions.map { "${it.type}:${it.id}" }.toSet()
-
-            // Download images for new/modified problems from server
-            val imagePathMapping = mutableMapOf<String, String>()
-            for (problem in response.problems) {
-                if (deletedItemSet.contains("problem:${problem.id}")) {
-                    continue
-                }
-                problem.imagePaths?.forEach { imagePath ->
-                    val serverFilename = imagePath.substringAfterLast('/')
-                    try {
-                        val localImagePath = downloadImage(serverFilename)
-                        if (localImagePath != null) {
-                            imagePathMapping[imagePath] = localImagePath
-                        }
-                    } catch (e: Exception) {
-                        AppLogger.w(TAG) { "Failed to download image $imagePath: ${e.message}" }
-                    }
-                }
-            }
-
-            // Merge gyms
-            val existingGyms = repository.getAllGyms().first()
-            for (backupGym in response.gyms) {
-                if (deletedItemSet.contains("gym:${backupGym.id}")) {
-                    continue
-                }
-                val existing = existingGyms.find { it.id == backupGym.id }
-                if (existing == null || backupGym.updatedAt >= existing.updatedAt) {
-                    val gym = backupGym.toGym()
-                    if (existing != null) {
-                        repository.updateGym(gym)
-                    } else {
-                        repository.insertGym(gym)
-                    }
-                }
-            }
-
-            // Merge problems
-            val existingProblems = repository.getAllProblems().first()
-            for (backupProblem in response.problems) {
-                if (deletedItemSet.contains("problem:${backupProblem.id}")) {
-                    continue
-                }
-                val updatedImagePaths =
-                    backupProblem.imagePaths?.map { oldPath ->
-                        imagePathMapping[oldPath] ?: oldPath
-                    }
-                val problemToMerge = backupProblem.copy(imagePaths = updatedImagePaths)
-                val problem = problemToMerge.toProblem()
-
-                val existing = existingProblems.find { it.id == backupProblem.id }
-                if (existing == null || backupProblem.updatedAt >= existing.updatedAt) {
-                    if (existing != null) {
-                        repository.updateProblem(problem)
-                    } else {
-                        repository.insertProblem(problem)
-                    }
-                }
-            }
-
-            // Merge sessions
-            val existingSessions = repository.getAllSessions().first()
-            for (backupSession in response.sessions) {
-                if (deletedItemSet.contains("session:${backupSession.id}")) {
-                    continue
-                }
-                val session = backupSession.toClimbSession()
-                val existing = existingSessions.find { it.id == backupSession.id }
-                if (existing == null || backupSession.updatedAt >= existing.updatedAt) {
-                    if (existing != null) {
-                        repository.updateSession(session)
-                    } else {
-                        repository.insertSession(session)
-                    }
-                }
-            }
-
-            // Merge attempts
-            val existingAttempts = repository.getAllAttempts().first()
-            for (backupAttempt in response.attempts) {
-                if (deletedItemSet.contains("attempt:${backupAttempt.id}")) {
-                    continue
-                }
-                val attempt = backupAttempt.toAttempt()
-                val existing = existingAttempts.find { it.id == backupAttempt.id }
-                if (existing == null || backupAttempt.createdAt >= existing.createdAt) {
-                    if (existing != null) {
-                        repository.updateAttempt(attempt)
-                    } else {
-                        repository.insertAttempt(attempt)
-                    }
-                }
-            }
-
-            // Apply deletions again for safety
-            applyDeletions(uniqueDeletions)
-
-            // Update deletion records
-            repository.clearDeletedItems()
-            uniqueDeletions.forEach { repository.trackDeletion(it.id, it.type) }
-        } finally {
-            // Re-enable auto-sync
-            repository.setAutoSyncCallback { serviceScope.launch { triggerAutoSync() } }
-        }
-    }
-
-    private suspend fun applyDeletions(
-        deletions: List<com.atridad.ascently.data.format.DeletedItem>
-    ) {
-        val existingGyms = repository.getAllGyms().first()
-        val existingProblems = repository.getAllProblems().first()
-        val existingSessions = repository.getAllSessions().first()
-        val existingAttempts = repository.getAllAttempts().first()
-
-        for (item in deletions) {
-            when (item.type) {
-                "gym" -> {
-                    existingGyms.find { it.id == item.id }?.let { repository.deleteGym(it) }
-                }
-
-                "problem" -> {
-                    existingProblems.find { it.id == item.id }?.let { repository.deleteProblem(it) }
-                }
-
-                "session" -> {
-                    existingSessions.find { it.id == item.id }?.let { repository.deleteSession(it) }
-                }
-
-                "attempt" -> {
-                    existingAttempts.find { it.id == item.id }?.let { repository.deleteAttempt(it) }
-                }
-            }
-        }
-    }
-
-    private suspend fun syncModifiedImages(modifiedProblems: List<BackupProblem>) {
-        if (modifiedProblems.isEmpty()) return
-
-        AppLogger.d(TAG) { "Syncing images for ${modifiedProblems.size} modified problems" }
-
-        for (backupProblem in modifiedProblems) {
-            backupProblem.imagePaths?.forEach { imagePath ->
-                val filename = imagePath.substringAfterLast('/')
-                uploadImage(imagePath, filename)
-            }
-        }
-    }
-
-    private suspend fun downloadData(): ClimbDataBackup {
-        val request =
-            Request.Builder()
-                .url("$serverUrl/sync")
-                .header("Authorization", "Bearer $authToken")
-                .get()
-                .build()
-
-        return withContext(Dispatchers.IO) {
-            try {
-                httpClient.newCall(request).execute().use { response ->
-                    if (response.isSuccessful) {
-                        val body = response.body?.string()
-                        if (!body.isNullOrEmpty()) {
-                            json.decodeFromString(body)
-                        } else {
-                            ClimbDataBackup(
-                                exportedAt = DateFormatUtils.nowISO8601(),
-                                gyms = emptyList(),
-                                problems = emptyList(),
-                                sessions = emptyList(),
-                                attempts = emptyList()
-                            )
-                        }
-                    } else {
-                        handleHttpError(response.code)
-                    }
-                }
-            } catch (e: IOException) {
-                throw SyncException.NetworkError(e.message ?: "Network error")
-            }
-        }
-    }
-
-    private suspend fun uploadData(backup: ClimbDataBackup) {
-        val requestBody =
-            json.encodeToString(backup).toRequestBody("application/json".toMediaType())
-
-        val request =
-            Request.Builder()
-                .url("$serverUrl/sync")
-                .header("Authorization", "Bearer $authToken")
-                .put(requestBody)
-                .build()
-
-        withContext(Dispatchers.IO) {
-            try {
-                httpClient.newCall(request).execute().use { response ->
-                    if (!response.isSuccessful) {
-                        handleHttpError(response.code)
-                    }
-                }
-            } catch (e: IOException) {
-                throw SyncException.NetworkError(e.message ?: "Network error")
-            }
-        }
-    }
-
-    private suspend fun syncImagesFromServer(backup: ClimbDataBackup): Map<String, String> {
-        val imagePathMapping = mutableMapOf<String, String>()
-        val totalImages = backup.problems.sumOf { it.imagePaths?.size ?: 0 }
-        AppLogger.d(TAG) { "Starting image download from server for $totalImages images" }
-
-        withContext(Dispatchers.IO) {
-            backup.problems.forEach { problem ->
-                problem.imagePaths?.forEach { imagePath ->
-                    val serverFilename = imagePath.substringAfterLast('/')
-                    try {
-                        val localImagePath = downloadImage(serverFilename)
-                        if (localImagePath != null) {
-                            imagePathMapping[imagePath] = localImagePath
-                        }
-                    } catch (_: SyncException.ImageNotFound) {
-                        AppLogger.w(TAG) { "Image not found on server: $imagePath" }
-                    } catch (e: Exception) {
-                        AppLogger.w(TAG) { "Failed to download image $imagePath: ${e.message}" }
-                    }
-                }
-            }
-        }
-        return imagePathMapping
-    }
-
-    private suspend fun downloadImage(serverFilename: String): String? {
-        val request =
-            Request.Builder()
-                .url("$serverUrl/images/download?filename=$serverFilename")
-                .header("Authorization", "Bearer $authToken")
-                .build()
-
-        return withContext(Dispatchers.IO) {
-            try {
-                httpClient.newCall(request).execute().use { response ->
-                    if (response.isSuccessful) {
-                        response.body?.bytes()?.let {
-                            ImageUtils.saveImageFromBytesWithFilename(context, it, serverFilename)
-                        }
-                    } else {
-                        if (response.code == 404) throw SyncException.ImageNotFound
-                        null
-                    }
-                }
-            } catch (e: IOException) {
-                AppLogger.e(TAG, e) { "Network error downloading image $serverFilename" }
-                null
-            }
-        }
-    }
-
-    private suspend fun syncImagesForBackup(backup: ClimbDataBackup) {
-        AppLogger.d(TAG) { "Starting image sync for backup with ${backup.problems.size} problems" }
-        withContext(Dispatchers.IO) {
-            backup.problems.forEach { problem ->
-                problem.imagePaths?.forEach { localPath ->
-                    val filename = localPath.substringAfterLast('/')
-                    uploadImage(localPath, filename)
-                }
-            }
-        }
-    }
-
-    private suspend fun uploadImage(localPath: String, filename: String) {
-        val file = ImageUtils.getImageFile(context, localPath)
-        if (!file.exists()) {
-            AppLogger.w(TAG) { "Local image file not found, cannot upload: $localPath" }
-            return
-        }
-
-        val requestBody = file.readBytes().toRequestBody("application/octet-stream".toMediaType())
-
-        val request =
-            Request.Builder()
-                .url("$serverUrl/images/upload?filename=$filename")
-                .header("Authorization", "Bearer $authToken")
-                .post(requestBody)
-                .build()
-
-        withContext(Dispatchers.IO) {
-            try {
-                httpClient.newCall(request).execute().use { response ->
-                    if (response.isSuccessful) {
-                        AppLogger.d(TAG) { "Successfully uploaded image: $filename" }
-                    } else {
-                        AppLogger.w(TAG) {
-                            "Failed to upload image $filename. Server responded with ${response.code}"
-                        }
-                    }
-                }
-            } catch (e: IOException) {
-                AppLogger.e(TAG, e) { "Network error uploading image $filename" }
-            }
-        }
-    }
-
-    private suspend fun createBackupFromRepository(): ClimbDataBackup {
-        return withContext(Dispatchers.Default) {
-            ClimbDataBackup(
-                exportedAt = dataStateManager.getLastModified(),
-                gyms = repository.getAllGyms().first().map { BackupGym.fromGym(it) },
-                problems =
-                    repository.getAllProblems().first().map { problem ->
-                        val backupProblem = BackupProblem.fromProblem(problem)
-                        val normalizedImagePaths =
-                            problem.imagePaths.mapIndexed { index, _ ->
-                                ImageNamingUtils.generateImageFilename(
-                                    problem.id,
-                                    index
-                                )
-                            }
-                        if (normalizedImagePaths.isNotEmpty()) {
-                            backupProblem.copy(imagePaths = normalizedImagePaths)
-                        } else {
-                            backupProblem
-                        }
-                    },
-                sessions =
-                    repository.getAllSessions().first().map {
-                        BackupClimbSession.fromClimbSession(it)
-                    },
-                attempts =
-                    repository.getAllAttempts().first().map {
-                        BackupAttempt.fromAttempt(it)
-                    },
-                deletedItems = repository.getDeletedItems()
-            )
-        }
-    }
-
-    private suspend fun importBackupToRepository(
-        backup: ClimbDataBackup,
-        imagePathMapping: Map<String, String>
-    ) {
-        val gyms = backup.gyms.map { it.toGym() }
-        val problems =
-            backup.problems.map { backupProblem ->
-                val imagePaths = backupProblem.imagePaths
-                val updatedImagePaths =
-                    imagePaths?.map { oldPath -> imagePathMapping[oldPath] ?: oldPath }
-                backupProblem.copy(imagePaths = updatedImagePaths).toProblem()
-            }
-        val sessions = backup.sessions.map { it.toClimbSession() }
-        val attempts = backup.attempts.map { it.toAttempt() }
-
-        repository.resetAllData()
-
-        gyms.forEach { repository.insertGymWithoutSync(it) }
-        problems.forEach { repository.insertProblemWithoutSync(it) }
-        sessions.forEach { repository.insertSessionWithoutSync(it) }
-        attempts.forEach { repository.insertAttemptWithoutSync(it) }
-
-        repository.clearDeletedItems()
-    }
-
-    private suspend fun mergeDataSafely(serverBackup: ClimbDataBackup) {
-        AppLogger.d(TAG) { "Server data will overwrite local data. Performing full restore." }
-        val imagePathMapping = syncImagesFromServer(serverBackup)
-        importBackupToRepository(serverBackup, imagePathMapping)
-    }
-
-    private fun handleHttpError(code: Int): Nothing {
-        when (code) {
-            401 -> throw SyncException.Unauthorized
-            in 500..599 -> throw SyncException.ServerError(code)
-            else -> throw SyncException.InvalidResponse("HTTP error code: $code")
-        }
-    }
-
    suspend fun testConnection() {
-        if (!_isConfigured.value) {
-            _isConnected.value = false
-            _syncError.value = "Server URL or Auth Token is not set."
-            return
-        }
        _isTesting.value = true
        _syncError.value = null
-
-        val request =
-            Request.Builder()
-                .url("$serverUrl/sync")
-                .header("Authorization", "Bearer $authToken")
-                .head()
-                .build()
        try {
-            withContext(Dispatchers.IO) {
-                httpClient.newCall(request).execute().use { response ->
-                    _isConnected.value = response.isSuccessful || response.code == 405
-                }
-            }
-            if (!_isConnected.value) {
-                _syncError.value = "Connection failed. Check URL and token."
-            }
+            provider.testConnection()
        } catch (e: Exception) {
-            _isConnected.value = false
            _syncError.value = "Connection error: ${e.message}"
+            throw e
        } finally {
-            sharedPreferences.edit { putBoolean(Keys.IS_CONNECTED, _isConnected.value) }
            _isTesting.value = false
        }
    }

    fun triggerAutoSync() {
-        if (!_isConfigured.value || !_isConnected.value || !_isAutoSyncEnabled.value) {
+        if (!isConfiguredFlow.value || !isConnected.value || !_isAutoSyncEnabled.value) {
            return
        }
        if (_isSyncing.value) {
@@ -812,30 +153,9 @@ class SyncService(private val context: Context, private val repository: ClimbRep

    fun clearConfiguration() {
        syncJob?.cancel()
-        serverUrl = ""
-        authToken = ""
+        provider.disconnect()
        setAutoSyncEnabled(true)
        _lastSyncTime.value = null
-        _isConnected.value = false
        _syncError.value = null
-        sharedPreferences.edit { clear() }
-        updateConfiguredState()
    }
 }
-
-sealed class SyncException(message: String) : IOException(message), Serializable {
-    object NotConfigured :
-        SyncException("Sync is not configured. Please set server URL and auth token.")
-
-    object NotConnected : SyncException("Not connected to server. Please test connection first.")
-
-    object Unauthorized : SyncException("Unauthorized. Please check your auth token.")
-
-    object ImageNotFound : SyncException("Image not found on server")
-
-    data class ServerError(val code: Int) : SyncException("Server error: HTTP $code")
-    data class InvalidResponse(val details: String) :
-        SyncException("Invalid server response: $details")
-
-    data class NetworkError(val details: String) : SyncException("Network error: $details")
-}
--- a/android/app/src/main/java/com/atridad/ascently/service/SessionTrackingService.kt
+++ b/android/app/src/main/java/com/atridad/ascently/service/SessionTrackingService.kt
@@ -6,6 +6,8 @@ import android.app.PendingIntent
 import android.app.Service
 import android.content.Context
 import android.content.Intent
+import android.os.Build
+import android.os.Bundle
 import android.os.IBinder
 import androidx.core.app.NotificationCompat
 import com.atridad.ascently.MainActivity
@@ -15,6 +17,7 @@ import com.atridad.ascently.data.repository.ClimbRepository
 import com.atridad.ascently.utils.AppLogger
 import com.atridad.ascently.widget.ClimbStatsWidgetProvider
 import java.time.LocalDateTime
+import java.time.ZoneId
 import java.time.temporal.ChronoUnit
 import kotlinx.coroutines.*
 import kotlinx.coroutines.flow.firstOrNull
@@ -209,33 +212,8 @@ class SessionTrackingService : Service() {
                repository.getAttemptsBySession(sessionId).firstOrNull() ?: emptyList()
            }

-            val duration =
-                session.startTime?.let { startTime ->
-                    try {
-                        val start = LocalDateTime.parse(startTime)
-                        val now = LocalDateTime.now()
-                        val totalSeconds = ChronoUnit.SECONDS.between(start, now)
-                        val hours = totalSeconds / 3600
-                        val minutes = (totalSeconds % 3600) / 60
-                        val seconds = totalSeconds % 60
-
-                        when {
-                            hours > 0 -> "${hours}h ${minutes}m ${seconds}s"
-                            minutes > 0 -> "${minutes}m ${seconds}s"
-                            else -> "${totalSeconds}s"
-                        }
-                    } catch (_: Exception) {
-                        "Active"
-                    }
-                }
-                    ?: "Active"
-
-            val notification =
+            val notificationBuilder =
                NotificationCompat.Builder(this, CHANNEL_ID)
-                    .setContentTitle("Climbing Session Active")
-                    .setContentText(
-                        "${gym?.name ?: "Gym"} • $duration • ${attempts.size} attempts"
-                    )
                    .setSmallIcon(R.drawable.ic_mountains)
                    .setOngoing(true)
                    .setAutoCancel(false)
@@ -253,7 +231,64 @@ class SessionTrackingService : Service() {
                        "End Session",
                        createStopPendingIntent(sessionId)
                    )
-                    .build()
+
+            // Use Live Update
+            if (Build.VERSION.SDK_INT >= 36) {
+                val startTimeMillis =
+                    session.startTime?.let { startTime ->
+                        try {
+                            val start = LocalDateTime.parse(startTime)
+                            val zoneId = ZoneId.systemDefault()
+                            start.atZone(zoneId).toInstant().toEpochMilli()
+                        } catch (_: Exception) {
+                            System.currentTimeMillis()
+                        }
+                    }
+                        ?: System.currentTimeMillis()
+
+                notificationBuilder
+                    .setContentTitle("Climbing Session Active")
+                    .setContentText(
+                        "${gym?.name ?: "Gym"} • ${attempts.size} attempts"
+                    )
+                    .setWhen(startTimeMillis)
+                    .setUsesChronometer(true)
+                    .setShowWhen(true)
+
+                val extras = Bundle()
+                extras.putBoolean("android.extra.REQUEST_PROMOTED_ONGOING", true)
+                notificationBuilder.setExtras(extras)
+            } else {
+                // Fallback for older versions
+                val duration =
+                    session.startTime?.let { startTime ->
+                        try {
+                            val start = LocalDateTime.parse(startTime)
+                            val now = LocalDateTime.now()
+                            val totalSeconds = ChronoUnit.SECONDS.between(start, now)
+                            val hours = totalSeconds / 3600
+                            val minutes = (totalSeconds % 3600) / 60
+                            val seconds = totalSeconds % 60
+
+                            when {
+                                hours > 0 -> "${hours}h ${minutes}m ${seconds}s"
+                                minutes > 0 -> "${minutes}m ${seconds}s"
+                                else -> "${totalSeconds}s"
+                            }
+                        } catch (_: Exception) {
+                            "Active"
+                        }
+                    }
+                        ?: "Active"
+
+                notificationBuilder
+                    .setContentTitle("Climbing Session Active")
+                    .setContentText(
+                        "${gym?.name ?: "Gym"} • $duration • ${attempts.size} attempts"
+                    )
+            }
+
+            val notification = notificationBuilder.build()

            startForeground(NOTIFICATION_ID, notification)

--- a/android/app/src/main/java/com/atridad/ascently/ui/screens/SessionsScreen.kt
+++ b/android/app/src/main/java/com/atridad/ascently/ui/screens/SessionsScreen.kt
@@ -5,8 +5,6 @@ import androidx.compose.foundation.background
 import androidx.compose.foundation.clickable
 import androidx.compose.foundation.layout.*
 import androidx.compose.foundation.lazy.LazyColumn
-import androidx.compose.foundation.lazy.grid.GridCells
-import androidx.compose.foundation.lazy.grid.LazyVerticalGrid
 import androidx.compose.foundation.lazy.items
 import androidx.compose.foundation.shape.CircleShape
 import androidx.compose.foundation.shape.RoundedCornerShape
@@ -38,6 +36,7 @@ import java.time.YearMonth
 import java.time.format.DateTimeFormatter
 import java.time.format.TextStyle
 import java.util.Locale
+import androidx.core.content.edit

 enum class ViewMode {
    LIST,
@@ -60,7 +59,7 @@ fun SessionsScreen(viewModel: ClimbViewModel, onNavigateToSessionDetail: (String
        mutableStateOf(if (savedViewMode == "CALENDAR") ViewMode.CALENDAR else ViewMode.LIST)
    }
    var selectedMonth by remember { mutableStateOf(YearMonth.now()) }
-    var selectedDate by remember { mutableStateOf<LocalDate?>(null) }
+    var selectedDate by remember { mutableStateOf<LocalDate?>(LocalDate.now()) }

    val completedSessions = sessions.filter { it.status == SessionStatus.COMPLETED }
    val activeSessionGym = activeSession?.let { session -> gyms.find { it.id == session.gymId } }
@@ -89,7 +88,7 @@ fun SessionsScreen(viewModel: ClimbViewModel, onNavigateToSessionDetail: (String
                        viewMode =
                                if (viewMode == ViewMode.LIST) ViewMode.CALENDAR else ViewMode.LIST
                        selectedDate = null
-                        sharedPreferences.edit().putString("view_mode", viewMode.name).apply()
+                        sharedPreferences.edit { putString("view_mode", viewMode.name) }
                    }
            ) {
                Icon(
@@ -147,16 +146,11 @@ fun SessionsScreen(viewModel: ClimbViewModel, onNavigateToSessionDetail: (String
                    CalendarView(
                            sessions = completedSessions,
                            gyms = gyms,
-                            activeSession = activeSession,
-                            activeSessionGym = activeSessionGym,
-                            selectedMonth = selectedMonth,
+                        selectedMonth = selectedMonth,
                            onMonthChange = { selectedMonth = it },
                            selectedDate = selectedDate,
                            onDateSelected = { selectedDate = it },
-                            onNavigateToSessionDetail = onNavigateToSessionDetail,
-                            onEndSession = {
-                                activeSession?.let { viewModel.endSession(context, it.id) }
-                            }
+                            onNavigateToSessionDetail = onNavigateToSessionDetail
                    )
                }
            }
@@ -315,14 +309,11 @@ fun EmptyStateMessage(
 fun CalendarView(
        sessions: List<ClimbSession>,
        gyms: List<com.atridad.ascently.data.model.Gym>,
-        activeSession: ClimbSession?,
-        activeSessionGym: com.atridad.ascently.data.model.Gym?,
        selectedMonth: YearMonth,
        onMonthChange: (YearMonth) -> Unit,
        selectedDate: LocalDate?,
        onDateSelected: (LocalDate?) -> Unit,
-        onNavigateToSessionDetail: (String) -> Unit,
-        onEndSession: () -> Unit
+        onNavigateToSessionDetail: (String) -> Unit
 ) {
    val sessionsByDate =
            remember(sessions) {
@@ -331,144 +322,155 @@ fun CalendarView(
                        java.time.Instant.parse(it.date)
                                .atZone(java.time.ZoneId.systemDefault())
                                .toLocalDate()
-                    } catch (e: Exception) {
+                    } catch (_: Exception) {
                        LocalDate.parse(it.date, DateTimeFormatter.ISO_LOCAL_DATE)
                    }
                }
            }

-    Column(modifier = Modifier.fillMaxSize()) {
-        Card(
-                modifier = Modifier.fillMaxWidth(),
-                colors =
-                        CardDefaults.cardColors(
-                                containerColor = MaterialTheme.colorScheme.surfaceVariant
-                        )
-        ) {
-            Column(
-                    modifier = Modifier.fillMaxWidth().padding(horizontal = 8.dp, vertical = 12.dp),
-                    horizontalAlignment = Alignment.CenterHorizontally
+    val firstDayOfMonth = selectedMonth.atDay(1)
+    val daysInMonth = selectedMonth.lengthOfMonth()
+    val firstDayOfWeek = firstDayOfMonth.dayOfWeek.value % 7
+    val totalCells =
+            ((firstDayOfWeek + daysInMonth) / 7.0).let {
+                if (it == it.toInt().toDouble()) it.toInt() * 7 else (it.toInt() + 1) * 7
+            }
+    val numRows = totalCells / 7
+
+    LazyColumn(modifier = Modifier.fillMaxSize()) {
+        item {
+            Card(
+                    modifier = Modifier.fillMaxWidth(),
+                    colors =
+                            CardDefaults.cardColors(
+                                    containerColor = MaterialTheme.colorScheme.surfaceVariant
+                            )
            ) {
-                Row(
-                        modifier = Modifier.fillMaxWidth(),
-                        horizontalArrangement = Arrangement.SpaceBetween,
-                        verticalAlignment = Alignment.CenterVertically
+                Column(
+                        modifier =
+                                Modifier.fillMaxWidth().padding(horizontal = 8.dp, vertical = 12.dp),
+                        horizontalAlignment = Alignment.CenterHorizontally
                ) {
-                    IconButton(onClick = { onMonthChange(selectedMonth.minusMonths(1)) }) {
-                        Text("‹", style = MaterialTheme.typography.headlineMedium)
+                    Row(
+                            modifier = Modifier.fillMaxWidth(),
+                            horizontalArrangement = Arrangement.SpaceBetween,
+                            verticalAlignment = Alignment.CenterVertically
+                    ) {
+                        IconButton(onClick = { onMonthChange(selectedMonth.minusMonths(1)) }) {
+                            Text("‹", style = MaterialTheme.typography.headlineMedium)
+                        }
+
+                        Text(
+                                text =
+                                        "${selectedMonth.month.getDisplayName(TextStyle.FULL, Locale.getDefault())} ${selectedMonth.year}",
+                                style = MaterialTheme.typography.titleMedium,
+                                fontWeight = FontWeight.Bold
+                        )
+
+                        IconButton(onClick = { onMonthChange(selectedMonth.plusMonths(1)) }) {
+                            Text("›", style = MaterialTheme.typography.headlineMedium)
+                        }
                    }

+                    Spacer(modifier = Modifier.height(8.dp))
+
+                    Button(
+                            onClick = {
+                                val today = LocalDate.now()
+                                onMonthChange(YearMonth.from(today))
+                                onDateSelected(today)
+                            },
+                            shape = RoundedCornerShape(50),
+                            colors =
+                                    ButtonDefaults.buttonColors(
+                                            containerColor = MaterialTheme.colorScheme.primary
+                                    ),
+                            contentPadding = PaddingValues(horizontal = 20.dp, vertical = 8.dp)
+                    ) {
+                        Text(
+                                text = "Today",
+                                style = MaterialTheme.typography.labelLarge,
+                                fontWeight = FontWeight.SemiBold
+                        )
+                    }
+                }
+            }
+
+            Spacer(modifier = Modifier.height(16.dp))
+
+            Row(modifier = Modifier.fillMaxWidth()) {
+                listOf("Sun", "Mon", "Tue", "Wed", "Thu", "Fri", "Sat").forEach { day ->
                    Text(
-                            text =
-                                    "${selectedMonth.month.getDisplayName(TextStyle.FULL, Locale.getDefault())} ${selectedMonth.year}",
-                            style = MaterialTheme.typography.titleMedium,
+                            text = day,
+                            modifier = Modifier.weight(1f),
+                            textAlign = TextAlign.Center,
+                            style = MaterialTheme.typography.labelSmall,
+                            color = MaterialTheme.colorScheme.onSurfaceVariant,
                            fontWeight = FontWeight.Bold
                    )
+                }
+            }

-                    IconButton(onClick = { onMonthChange(selectedMonth.plusMonths(1)) }) {
-                        Text("›", style = MaterialTheme.typography.headlineMedium)
+            Spacer(modifier = Modifier.height(8.dp))
+        }
+
+        items(numRows) { rowIndex ->
+            Row(modifier = Modifier.fillMaxWidth()) {
+                for (colIndex in 0 until 7) {
+                    val index = rowIndex * 7 + colIndex
+                    val dayNumber = index - firstDayOfWeek + 1
+
+                    Box(modifier = Modifier.weight(1f)) {
+                        if (dayNumber in 1..daysInMonth) {
+                            val date = selectedMonth.atDay(dayNumber)
+                            val sessionsOnDate = sessionsByDate[date] ?: emptyList()
+                            val isSelected = date == selectedDate
+                            val isToday = date == LocalDate.now()
+
+                            CalendarDay(
+                                    day = dayNumber,
+                                    hasSession = sessionsOnDate.isNotEmpty(),
+                                    isSelected = isSelected,
+                                    isToday = isToday,
+                                    onClick = {
+                                        if (sessionsOnDate.isNotEmpty()) {
+                                            onDateSelected(if (isSelected) null else date)
+                                        }
+                                    }
+                            )
+                        } else {
+                            Spacer(modifier = Modifier.aspectRatio(1f))
+                        }
                    }
                }
-
-                Spacer(modifier = Modifier.height(8.dp))
-
-                Button(
-                        onClick = {
-                            val today = LocalDate.now()
-                            onMonthChange(YearMonth.from(today))
-                            onDateSelected(today)
-                        },
-                        shape = RoundedCornerShape(50),
-                        colors =
-                                ButtonDefaults.buttonColors(
-                                        containerColor = MaterialTheme.colorScheme.primary
-                                ),
-                        contentPadding = PaddingValues(horizontal = 20.dp, vertical = 8.dp)
-                ) {
-                    Text(
-                            text = "Today",
-                            style = MaterialTheme.typography.labelLarge,
-                            fontWeight = FontWeight.SemiBold
-                    )
-                }
-            }
-        }
-
-        Spacer(modifier = Modifier.height(16.dp))
-
-        Row(modifier = Modifier.fillMaxWidth()) {
-            listOf("Sun", "Mon", "Tue", "Wed", "Thu", "Fri", "Sat").forEach { day ->
-                Text(
-                        text = day,
-                        modifier = Modifier.weight(1f),
-                        textAlign = TextAlign.Center,
-                        style = MaterialTheme.typography.labelSmall,
-                        color = MaterialTheme.colorScheme.onSurfaceVariant,
-                        fontWeight = FontWeight.Bold
-                )
-            }
-        }
-
-        Spacer(modifier = Modifier.height(8.dp))
-
-        val firstDayOfMonth = selectedMonth.atDay(1)
-        val daysInMonth = selectedMonth.lengthOfMonth()
-        val firstDayOfWeek = firstDayOfMonth.dayOfWeek.value % 7
-        val totalCells =
-                ((firstDayOfWeek + daysInMonth) / 7.0).let {
-                    if (it == it.toInt().toDouble()) it.toInt() * 7 else (it.toInt() + 1) * 7
-                }
-
-        LazyVerticalGrid(columns = GridCells.Fixed(7), modifier = Modifier.fillMaxWidth()) {
-            items(totalCells) { index ->
-                val dayNumber = index - firstDayOfWeek + 1
-
-                if (dayNumber in 1..daysInMonth) {
-                    val date = selectedMonth.atDay(dayNumber)
-                    val sessionsOnDate = sessionsByDate[date] ?: emptyList()
-                    val isSelected = date == selectedDate
-                    val isToday = date == LocalDate.now()
-
-                    CalendarDay(
-                            day = dayNumber,
-                            hasSession = sessionsOnDate.isNotEmpty(),
-                            isSelected = isSelected,
-                            isToday = isToday,
-                            onClick = {
-                                if (sessionsOnDate.isNotEmpty()) {
-                                    onDateSelected(if (isSelected) null else date)
-                                }
-                            }
-                    )
-                } else {
-                    Spacer(modifier = Modifier.aspectRatio(1f))
-                }
            }
        }

        if (selectedDate != null) {
            val sessionsOnSelectedDate = sessionsByDate[selectedDate] ?: emptyList()

-            Spacer(modifier = Modifier.height(16.dp))
+            item {
+                Spacer(modifier = Modifier.height(16.dp))

-            Text(
-                    text =
-                            "Sessions on ${selectedDate.format(DateTimeFormatter.ofPattern("MMMM d, yyyy"))}",
-                    style = MaterialTheme.typography.titleSmall,
-                    fontWeight = FontWeight.Bold,
-                    modifier = Modifier.padding(vertical = 8.dp)
-            )
-
-            LazyColumn(modifier = Modifier.fillMaxWidth()) {
-                items(sessionsOnSelectedDate) { session ->
-                    SessionCard(
-                            session = session,
-                            gymName = gyms.find { it.id == session.gymId }?.name ?: "Unknown Gym",
-                            onClick = { onNavigateToSessionDetail(session.id) }
-                    )
-                    Spacer(modifier = Modifier.height(8.dp))
-                }
+                Text(
+                        text =
+                                "Sessions on ${selectedDate.format(DateTimeFormatter.ofPattern("MMMM d, yyyy"))}",
+                        style = MaterialTheme.typography.titleSmall,
+                        fontWeight = FontWeight.Bold,
+                        modifier = Modifier.padding(vertical = 8.dp)
+                )
            }
+
+            items(sessionsOnSelectedDate) { session ->
+                SessionCard(
+                        session = session,
+                        gymName = gyms.find { it.id == session.gymId }?.name ?: "Unknown Gym",
+                        onClick = { onNavigateToSessionDetail(session.id) }
+                )
+                Spacer(modifier = Modifier.height(8.dp))
+            }
+
+            item { Spacer(modifier = Modifier.height(16.dp)) }
        }
    }
 }
--- a/android/app/src/main/java/com/atridad/ascently/ui/screens/SettingsScreen.kt
+++ b/android/app/src/main/java/com/atridad/ascently/ui/screens/SettingsScreen.kt
@@ -216,9 +216,7 @@ fun SettingsScreen(viewModel: ClimbViewModel) {
                                            // Manual Sync Button
                                            TextButton(
                                                    onClick = {
-                                                        coroutineScope.launch {
-                                                            viewModel.performManualSync()
-                                                        }
+                                                        viewModel.performManualSync()
                                                    },
                                                    enabled = isConnected && !isSyncing
                                            ) {
@@ -583,41 +581,6 @@ fun SettingsScreen(viewModel: ClimbViewModel) {

                    Spacer(modifier = Modifier.height(12.dp))

-                    Card(
-                            shape = RoundedCornerShape(12.dp),
-                            colors =
-                                    CardDefaults.cardColors(
-                                            containerColor =
-                                                    MaterialTheme.colorScheme.surfaceVariant.copy(
-                                                            alpha = 0.3f
-                                                    )
-                                    )
-                    ) {
-                        ListItem(
-                                headlineContent = {
-                                    Row(
-                                            verticalAlignment = Alignment.CenterVertically,
-                                            horizontalArrangement = Arrangement.spacedBy(8.dp)
-                                    ) {
-                                        Icon(
-                                                painter =
-                                                        painterResource(
-                                                                id = R.drawable.ic_mountains
-                                                        ),
-                                                contentDescription = "Ascently Logo",
-                                                modifier = Modifier.size(24.dp),
-                                                tint = MaterialTheme.colorScheme.primary
-                                        )
-                                        Text("Ascently")
-                                    }
-                                },
-                                supportingContent = { Text("Track your climbing progress") },
-                                leadingContent = {}
-                        )
-                    }
-
-                    Spacer(modifier = Modifier.height(8.dp))
-
                    Card(
                            shape = RoundedCornerShape(12.dp),
                            colors =
--- a/android/app/src/main/java/com/atridad/ascently/ui/viewmodel/ClimbViewModel.kt
+++ b/android/app/src/main/java/com/atridad/ascently/ui/viewmodel/ClimbViewModel.kt
@@ -411,11 +411,13 @@ class ClimbViewModel(
    }

    // Sync-related methods
-    suspend fun performManualSync() {
-        try {
-            syncService.syncWithServer()
-        } catch (e: Exception) {
-            setError("Sync failed: ${e.message}")
+    fun performManualSync() {
+        viewModelScope.launch {
+            try {
+                syncService.syncWithServer()
+            } catch (e: Exception) {
+                setError("Sync failed: ${e.message}")
+            }
        }
    }

--- a/android/app/src/main/res/xml/data_extraction_rules.xml
+++ b/android/app/src/main/res/xml/data_extraction_rules.xml
@@ -5,10 +5,6 @@
 -->
 <data-extraction-rules>
    <cloud-backup>
-        <!-- TODO: Use <include> and <exclude> to control what is backed up.
-        <include .../>
-        <exclude .../>
-        -->
    </cloud-backup>
    <!--
    <device-transfer>
--- a/android/gradle/libs.versions.toml
+++ b/android/gradle/libs.versions.toml
@@ -1,6 +1,6 @@
 [versions]
 agp = "8.12.3"
-kotlin = "2.2.20"
+kotlin = "2.2.21"
 coreKtx = "1.17.0"
 junit = "4.13.2"
 junitVersion = "1.3.0"
@@ -9,17 +9,17 @@ androidxTestCore = "1.7.0"
 androidxTestExt = "1.3.0"
 androidxTestRunner = "1.7.0"
 androidxTestRules = "1.7.0"
-lifecycleRuntimeKtx = "2.9.4"
-activityCompose = "1.11.0"
-composeBom = "2025.10.00"
-room = "2.8.2"
-navigation = "2.9.5"
-viewmodel = "2.9.4"
+lifecycleRuntimeKtx = "2.10.0"
+activityCompose = "1.12.0"
+composeBom = "2025.11.01"
+room = "2.8.4"
+navigation = "2.9.6"
+viewmodel = "2.10.0"
 kotlinxSerialization = "1.9.0"
 kotlinxCoroutines = "1.10.2"
 coil = "2.7.0"
 ksp = "2.2.20-2.0.3"
-exifinterface = "1.3.6"
+exifinterface = "1.4.1"

 [libraries]
 androidx-core-ktx = { group = "androidx.core", name = "core-ktx", version.ref = "coreKtx" }
--- a/docs/package.json
+++ b/docs/package.json
@@ -1,7 +1,7 @@
 {
  "name": "ascently-docs",
  "type": "module",
-  "version": "1.0.0",
+  "version": "1.1.0",
  "description": "Documentation site for Ascently - FOSS climbing tracking app",
  "repository": {
    "type": "git",
@@ -26,8 +26,8 @@
  },
  "dependencies": {
    "@astrojs/node": "^9.5.1",
-    "@astrojs/starlight": "^0.36.2",
-    "astro": "^5.16.0",
+    "@astrojs/starlight": "^0.37.0",
+    "astro": "^5.16.3",
    "qrcode": "^1.5.4",
    "sharp": "^0.34.5"
  },
--- a/docs/pnpm-lock.yaml
+++ b/docs/pnpm-lock.yaml
@@ -10,13 +10,13 @@ importers:
    dependencies:
      '@astrojs/node':
        specifier: ^9.5.1
-        version: 9.5.1(astro@5.16.0(@types/node@24.10.1)(rollup@4.53.3)(typescript@5.9.3))
+        version: 9.5.1(astro@5.16.3(@types/node@24.10.1)(rollup@4.53.3)(typescript@5.9.3))
      '@astrojs/starlight':
-        specifier: ^0.36.2
-        version: 0.36.2(astro@5.16.0(@types/node@24.10.1)(rollup@4.53.3)(typescript@5.9.3))
+        specifier: ^0.37.0
+        version: 0.37.0(astro@5.16.3(@types/node@24.10.1)(rollup@4.53.3)(typescript@5.9.3))
      astro:
-        specifier: ^5.16.0
-        version: 5.16.0(@types/node@24.10.1)(rollup@4.53.3)(typescript@5.9.3)
+        specifier: ^5.16.3
+        version: 5.16.3(@types/node@24.10.1)(rollup@4.53.3)(typescript@5.9.3)
      qrcode:
        specifier: ^1.5.4
        version: 1.5.4
@@ -57,8 +57,8 @@ packages:
  '@astrojs/sitemap@3.6.0':
    resolution: {integrity: sha512-4aHkvcOZBWJigRmMIAJwRQXBS+ayoP5z40OklTXYXhUDhwusz+DyDl+nSshY6y9DvkVEavwNcFO8FD81iGhXjg==}

-  '@astrojs/starlight@0.36.2':
-    resolution: {integrity: sha512-QR8NfO7+7DR13kBikhQwAj3IAoptLLNs9DkyKko2M2l3PrqpcpVUnw1JBJ0msGDIwE6tBbua2UeBND48mkh03w==}
+  '@astrojs/starlight@0.37.0':
+    resolution: {integrity: sha512-1AlaEjYYRO+5o6P5maPUBQZr6Q3wtuhMQTmsDQExI07wJVwe7EC2wGhXnFo+jpCjwHv/Bdg33PQheY4UhMj01g==}
    peerDependencies:
      astro: ^5.5.0

@@ -564,23 +564,23 @@ packages:
    cpu: [x64]
    os: [win32]

-  '@shikijs/core@3.15.0':
-    resolution: {integrity: sha512-8TOG6yG557q+fMsSVa8nkEDOZNTSxjbbR8l6lF2gyr6Np+jrPlslqDxQkN6rMXCECQ3isNPZAGszAfYoJOPGlg==}
+  '@shikijs/core@3.17.1':
+    resolution: {integrity: sha512-VWsduykcibGU0WMi66PflThDWyqEeTOiWdCRa3wmsZuishh+1PDSOh5gGxHdSrOtS+v1pmYaxodk/JNzwusElA==}

-  '@shikijs/engine-javascript@3.15.0':
-    resolution: {integrity: sha512-ZedbOFpopibdLmvTz2sJPJgns8Xvyabe2QbmqMTz07kt1pTzfEvKZc5IqPVO/XFiEbbNyaOpjPBkkr1vlwS+qg==}
+  '@shikijs/engine-javascript@3.17.1':
+    resolution: {integrity: sha512-Ars0DVJITQrkOl5Swwy+94NL/BlOi/w1NSFbPGkcsln7Dv+M2qHaVpNHwdtWCC4/arzvjuHbyWBUsWExDHPDLw==}

-  '@shikijs/engine-oniguruma@3.15.0':
-    resolution: {integrity: sha512-HnqFsV11skAHvOArMZdLBZZApRSYS4LSztk2K3016Y9VCyZISnlYUYsL2hzlS7tPqKHvNqmI5JSUJZprXloMvA==}
+  '@shikijs/engine-oniguruma@3.17.1':
+    resolution: {integrity: sha512-fsXPy4va/4iblEGS+22nP5V08IwwBcM+8xHUzSON0QmHm29/AJRghA95w9VDnxuwp9wOdJxEhfPkKp6vqcsN+w==}

-  '@shikijs/langs@3.15.0':
-    resolution: {integrity: sha512-WpRvEFvkVvO65uKYW4Rzxs+IG0gToyM8SARQMtGGsH4GDMNZrr60qdggXrFOsdfOVssG/QQGEl3FnJ3EZ+8w8A==}
+  '@shikijs/langs@3.17.1':
+    resolution: {integrity: sha512-YTBVN+L2j7zBuOVjNZ2XiSNQEkm/7wZ1TSc5UO77GJPcg7Rk25WSscWA7y8pW7Bo25JIU0EWchUkq/UQjOJlJA==}

-  '@shikijs/themes@3.15.0':
-    resolution: {integrity: sha512-8ow2zWb1IDvCKjYb0KiLNrK4offFdkfNVPXb1OZykpLCzRU6j+efkY+Y7VQjNlNFXonSw+4AOdGYtmqykDbRiQ==}
+  '@shikijs/themes@3.17.1':
+    resolution: {integrity: sha512-aohwwqNUB5h2ATfgrqYRPl8vyazqCiQ2wIV4xq+UzaBRHpqLMGSemkasK+vIEpl0YaendoaKUsDfpwhCqyHIaQ==}

-  '@shikijs/types@3.15.0':
-    resolution: {integrity: sha512-BnP+y/EQnhihgHy4oIAN+6FFtmfTekwOLsQbRw9hOKwqgNy8Bdsjq8B05oAt/ZgvIWWFrshV71ytOrlPfYjIJw==}
+  '@shikijs/types@3.17.1':
+    resolution: {integrity: sha512-yUFLiCnZHHJ16KbVbt3B1EzBUadU3OVpq0PEyb301m5BbuFKApQYBzJGhrK48hH/tYWSjzwcj7BSmYbBc0zntQ==}

  '@shikijs/vscode-textmate@10.0.2':
    resolution: {integrity: sha512-83yeghZ2xxin3Nj8z1NMd/NCuca+gsYXswywDy5bHvwlWL8tpTQmzGeUuHd9FC3E/SBEMvzJRwWEOz5gGes9Qg==}
@@ -694,8 +694,8 @@ packages:
    peerDependencies:
      astro: ^4.0.0-beta || ^5.0.0-beta || ^3.3.0

-  astro@5.16.0:
-    resolution: {integrity: sha512-GaDRs2Mngpw3dr2vc085GnORh98NiXxwIjg/EoQQQl/icZt3Z7s0BRsYHDZ8swkZbOA6wZsqWJdrNirl+iKcDg==}
+  astro@5.16.3:
+    resolution: {integrity: sha512-KzDk41F9Dspf5fM/Ls4XZhV4/csjJcWBrlenbnp5V3NGwU1zEaJz/HIyrdKdf5yw+FgwCeD2+Yos1Xkx9gnI0A==}
    engines: {node: 18.20.8 || ^20.3.0 || >=22.0.0, npm: '>=9.6.5', pnpm: '>=7.1.0'}
    hasBin: true

@@ -801,8 +801,8 @@ packages:
  cookie-es@1.2.2:
    resolution: {integrity: sha512-+W7VmiVINB+ywl1HGXJXmrqkOhpKrIiVZV6tQuV54ZyQC7MMuBt81Vc336GMLoHBq5hV/F9eXgt5Mnx0Rha5Fg==}

-  cookie@1.0.2:
-    resolution: {integrity: sha512-9Kr/j4O16ISv8zBBhJoi4bXOYNTkFLOqSL3UDB0njXxCXNezjeyVrJyGOWtgfs/q2km1gwBcfH8q1yEGoMYunA==}
+  cookie@1.1.1:
+    resolution: {integrity: sha512-ei8Aos7ja0weRpFzJnEA9UHJ/7XQmqglbRwnf2ATjcB9Wq874VKH9kfjjirM6UhU2/E5fFYadylyhFldcqSidQ==}
    engines: {node: '>=18'}

  crossws@0.3.5:
@@ -1246,8 +1246,8 @@ packages:
  mdast-util-phrasing@4.1.0:
    resolution: {integrity: sha512-TqICwyvJJpBwvGAMZjj4J2n0X8QWp21b9l0o7eXyVJ25YNWYbJDVIyD1bZXE6WtV6RmKJVYmQAKWa0zWOABz2w==}

-  mdast-util-to-hast@13.2.0:
-    resolution: {integrity: sha512-QGYKEuUsYT9ykKBCMOEDLsU5JRObWQusAolFMeko/tYPufNkRffBAQjIE+99jbA87xv6FgmjLtwjh9wBWajwAA==}
+  mdast-util-to-hast@13.2.1:
+    resolution: {integrity: sha512-cctsq2wp5vTsLIcaymblUriiTcZd0CwWtCbLvrOzYCDZoWyMNV8sZ7krj09FSnsiJi3WVsHLM4k6Dq/yaPyCXA==}

  mdast-util-to-markdown@2.1.2:
    resolution: {integrity: sha512-xj68wMTvGXVOKonmog6LwyJKrYXZPvlwabaryTjLh9LuvovB/KAH+kvi8Gjj+7rJjsFi23nkUxRQv1KqSroMqA==}
@@ -1422,8 +1422,8 @@ packages:
  oniguruma-parser@0.12.1:
    resolution: {integrity: sha512-8Unqkvk1RYc6yq2WBYRj4hdnsAxVze8i7iPfQr8e4uSP3tRv0rpZcbGUDvxfQQcdwHt/e9PrMvGCsa8OqG9X3w==}

-  oniguruma-to-es@4.3.3:
-    resolution: {integrity: sha512-rPiZhzC3wXwE59YQMRDodUwwT9FZ9nNBwQQfsd1wfdtlKEyCdRV0avrTcSZ5xlIvGRVPd/cx6ZN45ECmS39xvg==}
+  oniguruma-to-es@4.3.4:
+    resolution: {integrity: sha512-3VhUGN3w2eYxnTzHn+ikMI+fp/96KoRSVK9/kMTcFqj1NRDh2IhQCKvYxDnWePKRXY/AqH+Fuiyb7VHSzBjHfA==}

  p-limit@2.3.0:
    resolution: {integrity: sha512-//88mFWSJx8lxCzwdAABTJL2MyWB12+eIY7MDL2SqLmAkeKU9qxRvWuSyTjm3FUmpBEMuFfckAIqEaVGUDxb6w==}
@@ -1449,8 +1449,8 @@ packages:
    resolution: {integrity: sha512-R4nPAVTAU0B9D35/Gk3uJf/7XYbQcyohSKdvAxIRSNghFl4e71hVoGnBNQz9cWaXxO2I10KTC+3jMdvvoKw6dQ==}
    engines: {node: '>=6'}

-  package-manager-detector@1.5.0:
-    resolution: {integrity: sha512-uBj69dVlYe/+wxj8JOpr97XfsxH/eumMt6HqjNTmJDf/6NO9s+0uxeOneIz3AsPt2m6y9PqzDzd3ATcU17MNfw==}
+  package-manager-detector@1.6.0:
+    resolution: {integrity: sha512-61A5ThoTiDG/C8s8UMZwSorAGwMJ0ERVGj2OjoW5pAalsNOg15+iQiPzrLJ4jhZ1HJzmC2PIHT2oEiH3R5fzNA==}

  pagefind@1.4.0:
    resolution: {integrity: sha512-z2kY1mQlL4J8q5EIsQkLzQjilovKzfNVhX8De6oyE6uHpfFtyBaqUpcl/XzJC/4fjD8vBDyh1zolimIcVrCn9g==}
@@ -1652,8 +1652,8 @@ packages:
    resolution: {integrity: sha512-Ou9I5Ft9WNcCbXrU9cMgPBcCK8LiwLqcbywW3t4oDV37n1pzpuNLsYiAV8eODnjbtQlSDwZ2cUEeQz4E54Hltg==}
    engines: {node: ^18.17.0 || ^20.3.0 || >=21.0.0}

-  shiki@3.15.0:
-    resolution: {integrity: sha512-kLdkY6iV3dYbtPwS9KXU7mjfmDm25f5m0IPNFnaXO7TBPcvbUOY72PYXSuSqDzwp+vlH/d7MXpHlKO/x+QoLXw==}
+  shiki@3.17.1:
+    resolution: {integrity: sha512-KbAPJo6pQpfjupOg5HW0fk/OSmeBfzza2IjZ5XbNKbqhZaCoxro/EyOgesaLvTdyDfrsAUDA6L4q14sc+k9i7g==}

  sisteransi@1.0.5:
    resolution: {integrity: sha512-bLGGlR1QxBcynn2d5YmDX4MGjlZvy2MRBDRNHLJ8VI6l6+9FUiyTFNJ0IveOSP0bcXgVDPRcfGqA0pjaqUpfVg==}
@@ -2025,7 +2025,7 @@ snapshots:
      remark-parse: 11.0.0
      remark-rehype: 11.1.2
      remark-smartypants: 3.0.2
-      shiki: 3.15.0
+      shiki: 3.17.1
      smol-toml: 1.5.2
      unified: 11.0.5
      unist-util-remove-position: 5.0.0
@@ -2035,12 +2035,12 @@ snapshots:
    transitivePeerDependencies:
      - supports-color

-  '@astrojs/mdx@4.3.12(astro@5.16.0(@types/node@24.10.1)(rollup@4.53.3)(typescript@5.9.3))':
+  '@astrojs/mdx@4.3.12(astro@5.16.3(@types/node@24.10.1)(rollup@4.53.3)(typescript@5.9.3))':
    dependencies:
      '@astrojs/markdown-remark': 6.3.9
      '@mdx-js/mdx': 3.1.1
      acorn: 8.15.0
-      astro: 5.16.0(@types/node@24.10.1)(rollup@4.53.3)(typescript@5.9.3)
+      astro: 5.16.3(@types/node@24.10.1)(rollup@4.53.3)(typescript@5.9.3)
      es-module-lexer: 1.7.0
      estree-util-visit: 2.0.0
      hast-util-to-html: 9.0.5
@@ -2054,10 +2054,10 @@ snapshots:
    transitivePeerDependencies:
      - supports-color

-  '@astrojs/node@9.5.1(astro@5.16.0(@types/node@24.10.1)(rollup@4.53.3)(typescript@5.9.3))':
+  '@astrojs/node@9.5.1(astro@5.16.3(@types/node@24.10.1)(rollup@4.53.3)(typescript@5.9.3))':
    dependencies:
      '@astrojs/internal-helpers': 0.7.5
-      astro: 5.16.0(@types/node@24.10.1)(rollup@4.53.3)(typescript@5.9.3)
+      astro: 5.16.3(@types/node@24.10.1)(rollup@4.53.3)(typescript@5.9.3)
      send: 1.2.0
      server-destroy: 1.0.1
    transitivePeerDependencies:
@@ -2073,17 +2073,17 @@ snapshots:
      stream-replace-string: 2.0.0
      zod: 3.25.76

-  '@astrojs/starlight@0.36.2(astro@5.16.0(@types/node@24.10.1)(rollup@4.53.3)(typescript@5.9.3))':
+  '@astrojs/starlight@0.37.0(astro@5.16.3(@types/node@24.10.1)(rollup@4.53.3)(typescript@5.9.3))':
    dependencies:
      '@astrojs/markdown-remark': 6.3.9
-      '@astrojs/mdx': 4.3.12(astro@5.16.0(@types/node@24.10.1)(rollup@4.53.3)(typescript@5.9.3))
+      '@astrojs/mdx': 4.3.12(astro@5.16.3(@types/node@24.10.1)(rollup@4.53.3)(typescript@5.9.3))
      '@astrojs/sitemap': 3.6.0
      '@pagefind/default-ui': 1.4.0
      '@types/hast': 3.0.4
      '@types/js-yaml': 4.0.9
      '@types/mdast': 4.0.4
-      astro: 5.16.0(@types/node@24.10.1)(rollup@4.53.3)(typescript@5.9.3)
-      astro-expressive-code: 0.41.3(astro@5.16.0(@types/node@24.10.1)(rollup@4.53.3)(typescript@5.9.3))
+      astro: 5.16.3(@types/node@24.10.1)(rollup@4.53.3)(typescript@5.9.3)
+      astro-expressive-code: 0.41.3(astro@5.16.3(@types/node@24.10.1)(rollup@4.53.3)(typescript@5.9.3))
      bcp-47: 2.1.0
      hast-util-from-html: 2.0.3
      hast-util-select: 6.0.4
@@ -2092,6 +2092,7 @@ snapshots:
      i18next: 23.16.8
      js-yaml: 4.1.1
      klona: 2.0.6
+      magic-string: 0.30.21
      mdast-util-directive: 3.1.0
      mdast-util-to-markdown: 2.1.2
      mdast-util-to-string: 4.0.0
@@ -2241,7 +2242,7 @@ snapshots:
  '@expressive-code/plugin-shiki@0.41.3':
    dependencies:
      '@expressive-code/core': 0.41.3
-      shiki: 3.15.0
+      shiki: 3.17.1

  '@expressive-code/plugin-text-markers@0.41.3':
    dependencies:
@@ -2471,33 +2472,33 @@ snapshots:
  '@rollup/rollup-win32-x64-msvc@4.53.3':
    optional: true

-  '@shikijs/core@3.15.0':
+  '@shikijs/core@3.17.1':
    dependencies:
-      '@shikijs/types': 3.15.0
+      '@shikijs/types': 3.17.1
      '@shikijs/vscode-textmate': 10.0.2
      '@types/hast': 3.0.4
      hast-util-to-html: 9.0.5

-  '@shikijs/engine-javascript@3.15.0':
+  '@shikijs/engine-javascript@3.17.1':
    dependencies:
-      '@shikijs/types': 3.15.0
+      '@shikijs/types': 3.17.1
      '@shikijs/vscode-textmate': 10.0.2
-      oniguruma-to-es: 4.3.3
+      oniguruma-to-es: 4.3.4

-  '@shikijs/engine-oniguruma@3.15.0':
+  '@shikijs/engine-oniguruma@3.17.1':
    dependencies:
-      '@shikijs/types': 3.15.0
+      '@shikijs/types': 3.17.1
      '@shikijs/vscode-textmate': 10.0.2

-  '@shikijs/langs@3.15.0':
+  '@shikijs/langs@3.17.1':
    dependencies:
-      '@shikijs/types': 3.15.0
+      '@shikijs/types': 3.17.1

-  '@shikijs/themes@3.15.0':
+  '@shikijs/themes@3.17.1':
    dependencies:
-      '@shikijs/types': 3.15.0
+      '@shikijs/types': 3.17.1

-  '@shikijs/types@3.15.0':
+  '@shikijs/types@3.17.1':
    dependencies:
      '@shikijs/vscode-textmate': 10.0.2
      '@types/hast': 3.0.4
@@ -2595,12 +2596,12 @@ snapshots:

  astring@1.9.0: {}

-  astro-expressive-code@0.41.3(astro@5.16.0(@types/node@24.10.1)(rollup@4.53.3)(typescript@5.9.3)):
+  astro-expressive-code@0.41.3(astro@5.16.3(@types/node@24.10.1)(rollup@4.53.3)(typescript@5.9.3)):
    dependencies:
-      astro: 5.16.0(@types/node@24.10.1)(rollup@4.53.3)(typescript@5.9.3)
+      astro: 5.16.3(@types/node@24.10.1)(rollup@4.53.3)(typescript@5.9.3)
      rehype-expressive-code: 0.41.3

-  astro@5.16.0(@types/node@24.10.1)(rollup@4.53.3)(typescript@5.9.3):
+  astro@5.16.3(@types/node@24.10.1)(rollup@4.53.3)(typescript@5.9.3):
    dependencies:
      '@astrojs/compiler': 2.13.0
      '@astrojs/internal-helpers': 0.7.5
@@ -2616,7 +2617,7 @@ snapshots:
      ci-info: 4.3.1
      clsx: 2.1.1
      common-ancestor-path: 1.0.1
-      cookie: 1.0.2
+      cookie: 1.1.1
      cssesc: 3.0.0
      debug: 4.4.3
      deterministic-object-hash: 2.0.2
@@ -2640,13 +2641,13 @@ snapshots:
      neotraverse: 0.6.18
      p-limit: 6.2.0
      p-queue: 8.1.1
-      package-manager-detector: 1.5.0
+      package-manager-detector: 1.6.0
      piccolore: 0.1.3
      picomatch: 4.0.3
      prompts: 2.4.2
      rehype: 13.0.2
      semver: 7.7.3
-      shiki: 3.15.0
+      shiki: 3.17.1
      smol-toml: 1.5.2
      svgo: 4.0.0
      tinyexec: 1.0.2
@@ -2785,7 +2786,7 @@ snapshots:

  cookie-es@1.2.2: {}

-  cookie@1.0.2: {}
+  cookie@1.1.1: {}

  crossws@0.3.5:
    dependencies:
@@ -3116,7 +3117,7 @@ snapshots:
      hast-util-from-parse5: 8.0.3
      hast-util-to-parse5: 8.0.0
      html-void-elements: 3.0.0
-      mdast-util-to-hast: 13.2.0
+      mdast-util-to-hast: 13.2.1
      parse5: 7.3.0
      unist-util-position: 5.0.0
      unist-util-visit: 5.0.0
@@ -3171,7 +3172,7 @@ snapshots:
      comma-separated-tokens: 2.0.3
      hast-util-whitespace: 3.0.0
      html-void-elements: 3.0.0
-      mdast-util-to-hast: 13.2.0
+      mdast-util-to-hast: 13.2.1
      property-information: 7.1.0
      space-separated-tokens: 2.0.2
      stringify-entities: 4.0.4
@@ -3468,7 +3469,7 @@ snapshots:
      '@types/mdast': 4.0.4
      unist-util-is: 6.0.1

-  mdast-util-to-hast@13.2.0:
+  mdast-util-to-hast@13.2.1:
    dependencies:
      '@types/hast': 3.0.4
      '@types/mdast': 4.0.4
@@ -3816,7 +3817,7 @@ snapshots:

  oniguruma-parser@0.12.1: {}

-  oniguruma-to-es@4.3.3:
+  oniguruma-to-es@4.3.4:
    dependencies:
      oniguruma-parser: 0.12.1
      regex: 6.0.1
@@ -3843,7 +3844,7 @@ snapshots:

  p-try@2.2.0: {}

-  package-manager-detector@1.5.0: {}
+  package-manager-detector@1.6.0: {}

  pagefind@1.4.0:
    optionalDependencies:
@@ -4051,7 +4052,7 @@ snapshots:
    dependencies:
      '@types/hast': 3.0.4
      '@types/mdast': 4.0.4
-      mdast-util-to-hast: 13.2.0
+      mdast-util-to-hast: 13.2.1
      unified: 11.0.5
      vfile: 6.0.3

@@ -4184,14 +4185,14 @@ snapshots:
      '@img/sharp-win32-ia32': 0.34.5
      '@img/sharp-win32-x64': 0.34.5

-  shiki@3.15.0:
+  shiki@3.17.1:
    dependencies:
-      '@shikijs/core': 3.15.0
-      '@shikijs/engine-javascript': 3.15.0
-      '@shikijs/engine-oniguruma': 3.15.0
-      '@shikijs/langs': 3.15.0
-      '@shikijs/themes': 3.15.0
-      '@shikijs/types': 3.15.0
+      '@shikijs/core': 3.17.1
+      '@shikijs/engine-javascript': 3.17.1
+      '@shikijs/engine-oniguruma': 3.17.1
+      '@shikijs/langs': 3.17.1
+      '@shikijs/themes': 3.17.1
+      '@shikijs/types': 3.17.1
      '@shikijs/vscode-textmate': 10.0.2
      '@types/hast': 3.0.4

--- a/docs/src/config.ts
+++ b/docs/src/config.ts
@@ -5,7 +5,7 @@ export const requirements = {

 export const downloadLinks = {
  android: {
-    releases: "https://git.atri.dad/atridad/Ascently/releases",
+    releases: "https://git.atri.dad/atridad/Ascently/tags?q=Android",
    obtainium:
      "https://apps.obtainium.imranr.dev/redirect?r=obtainium://add/https://git.atri.dad/atridad/Ascently/releases",
    playStore: "",
--- a/ios/Ascently.xcodeproj/project.pbxproj
+++ b/ios/Ascently.xcodeproj/project.pbxproj
@@ -465,7 +465,7 @@
 				CODE_SIGN_ENTITLEMENTS = Ascently/Ascently.entitlements;
 				CODE_SIGN_IDENTITY = "Apple Development";
 				CODE_SIGN_STYLE = Automatic;
-				CURRENT_PROJECT_VERSION = 32;
+				CURRENT_PROJECT_VERSION = 38;
 				DEVELOPMENT_TEAM = 4BC9Y2LL4B;
 				DRIVERKIT_DEPLOYMENT_TARGET = 24.6;
 				ENABLE_PREVIEWS = YES;
@@ -487,7 +487,7 @@
 					"@executable_path/Frameworks",
 				);
 				MACOSX_DEPLOYMENT_TARGET = 15.6;
-				MARKETING_VERSION = 2.3.0;
+				MARKETING_VERSION = 2.5.1;
 				PRODUCT_BUNDLE_IDENTIFIER = com.atridad.Ascently;
 				PRODUCT_NAME = "$(TARGET_NAME)";
 				PROVISIONING_PROFILE_SPECIFIER = "";
@@ -513,7 +513,7 @@
 				CODE_SIGN_ENTITLEMENTS = Ascently/Ascently.entitlements;
 				CODE_SIGN_IDENTITY = "Apple Development";
 				CODE_SIGN_STYLE = Automatic;
-				CURRENT_PROJECT_VERSION = 32;
+				CURRENT_PROJECT_VERSION = 38;
 				DEVELOPMENT_TEAM = 4BC9Y2LL4B;
 				DRIVERKIT_DEPLOYMENT_TARGET = 24.6;
 				ENABLE_PREVIEWS = YES;
@@ -535,7 +535,7 @@
 					"@executable_path/Frameworks",
 				);
 				MACOSX_DEPLOYMENT_TARGET = 15.6;
-				MARKETING_VERSION = 2.3.0;
+				MARKETING_VERSION = 2.5.1;
 				PRODUCT_BUNDLE_IDENTIFIER = com.atridad.Ascently;
 				PRODUCT_NAME = "$(TARGET_NAME)";
 				PROVISIONING_PROFILE_SPECIFIER = "";
@@ -602,7 +602,7 @@
 				ASSETCATALOG_COMPILER_WIDGET_BACKGROUND_COLOR_NAME = WidgetBackground;
 				CODE_SIGN_ENTITLEMENTS = SessionStatusLiveExtension.entitlements;
 				CODE_SIGN_STYLE = Automatic;
-				CURRENT_PROJECT_VERSION = 32;
+				CURRENT_PROJECT_VERSION = 38;
 				DEVELOPMENT_TEAM = 4BC9Y2LL4B;
 				GENERATE_INFOPLIST_FILE = YES;
 				INFOPLIST_FILE = SessionStatusLive/Info.plist;
@@ -613,7 +613,7 @@
 					"@executable_path/Frameworks",
 					"@executable_path/../../Frameworks",
 				);
-				MARKETING_VERSION = 2.3.0;
+				MARKETING_VERSION = 2.5.1;
 				PRODUCT_BUNDLE_IDENTIFIER = com.atridad.Ascently.SessionStatusLive;
 				PRODUCT_NAME = "$(TARGET_NAME)";
 				SKIP_INSTALL = YES;
@@ -632,7 +632,7 @@
 				ASSETCATALOG_COMPILER_WIDGET_BACKGROUND_COLOR_NAME = WidgetBackground;
 				CODE_SIGN_ENTITLEMENTS = SessionStatusLiveExtension.entitlements;
 				CODE_SIGN_STYLE = Automatic;
-				CURRENT_PROJECT_VERSION = 32;
+				CURRENT_PROJECT_VERSION = 38;
 				DEVELOPMENT_TEAM = 4BC9Y2LL4B;
 				GENERATE_INFOPLIST_FILE = YES;
 				INFOPLIST_FILE = SessionStatusLive/Info.plist;
@@ -643,7 +643,7 @@
 					"@executable_path/Frameworks",
 					"@executable_path/../../Frameworks",
 				);
-				MARKETING_VERSION = 2.3.0;
+				MARKETING_VERSION = 2.5.1;
 				PRODUCT_BUNDLE_IDENTIFIER = com.atridad.Ascently.SessionStatusLive;
 				PRODUCT_NAME = "$(TARGET_NAME)";
 				SKIP_INSTALL = YES;
--- a/ios/Ascently.xcodeproj/project.xcworkspace/xcuserdata/atridad.xcuserdatad/UserInterfaceState.xcuserstate
+++ b/ios/Ascently.xcodeproj/project.xcworkspace/xcuserdata/atridad.xcuserdatad/UserInterfaceState.xcuserstate
--- a/ios/Ascently/AppIntents/AscentlyShortcuts.swift
+++ b/ios/Ascently/AppIntents/AscentlyShortcuts.swift
@@ -1,7 +1,6 @@
 import AppIntents

-/// Provides a curated list of the most useful Ascently shortcuts for Siri and the Shortcuts app.
-/// Surfaces intents that users can trigger hands-free to manage their climbing sessions.
+/// Defines the App Shortcuts available in the Shortcuts app.
 struct AscentlyShortcuts: AppShortcutsProvider {

    static var shortcutTileColor: ShortcutTileColor {
@@ -11,23 +10,15 @@ struct AscentlyShortcuts: AppShortcutsProvider {
    static var appShortcuts: [AppShortcut] {
        return [
            AppShortcut(
-                intent: StartLastGymSessionIntent(),
+                intent: ToggleSessionIntent(),
                phrases: [
-                    "Start my climb in \(.applicationName)",
-                    "Begin my last gym session in \(.applicationName)",
+                    "Toggle climb in \(.applicationName)",
+                    "Start or stop climb in \(.applicationName)",
+                    "Climb toggle in \(.applicationName)",
                ],
-                shortTitle: "Start Climb",
+                shortTitle: "Toggle Session",
                systemImageName: "figure.climbing"
-            ),
-            AppShortcut(
-                intent: EndActiveSessionIntent(),
-                phrases: [
-                    "Finish my climb in \(.applicationName)",
-                    "End my session in \(.applicationName)",
-                ],
-                shortTitle: "End Climb",
-                systemImageName: "flag.checkered"
-            ),
+            )
        ]
    }
 }
--- a/ios/Ascently/AppIntents/EndActiveSessionIntent.swift
+++ b/ios/Ascently/AppIntents/EndActiveSessionIntent.swift
@@ -1,40 +0,0 @@
-import AppIntents
-import Foundation
-
-/// Ends the currently active climbing session so logging stays in sync across devices.
-/// Exposed to Shortcuts so users can wrap up a session without opening the app.
-struct EndActiveSessionIntent: AppIntent {
-
-    static var title: LocalizedStringResource {
-        "End Active Session"
-    }
-
-    static var description: IntentDescription {
-        IntentDescription(
-            "Stop the active climbing session and save its progress in Ascently."
-        )
-    }
-
-    static var openAppWhenRun: Bool {
-        false
-    }
-
-    func perform() async throws -> some IntentResult & ProvidesDialog {
-        do {
-            let summary = try await SessionIntentController().endActiveSession()
-            let dialog = IntentDialog("Session at \(summary.gymName) ended. Nice work!")
-            return .result(dialog: dialog)
-        } catch SessionIntentError.noActiveSession {
-            // No active session is fine - just return a friendly message
-            let dialog = IntentDialog("No active session to end.")
-            return .result(dialog: dialog)
-        } catch {
-            // Re-throw other errors
-            throw error
-        }
-    }
-
-    static var parameterSummary: some ParameterSummary {
-        Summary("End my current climbing session")
-    }
-}
--- a/ios/Ascently/AppIntents/SessionIntentSupport.swift
+++ b/ios/Ascently/AppIntents/SessionIntentSupport.swift
@@ -27,7 +27,7 @@ struct SessionIntentSummary: Sendable {
    let status: SessionStatus
 }

-/// Central controller that exposes the minimal climbing session operations used by App Intents and shortcuts.
+/// Controller for handling session operations from App Intents.
@MainActor
 final class SessionIntentController {

@@ -39,9 +39,9 @@ final class SessionIntentController {

    /// Starts a new session using the most recently visited gym.
    func startSessionWithLastUsedGym() async throws -> SessionIntentSummary {
-        // Give a moment for data to be ready if app just launched
+        // Wait for data to load
        if dataManager.gyms.isEmpty {
-            try? await Task.sleep(nanoseconds: 500_000_000)  // 0.5 seconds
+            try? await Task.sleep(nanoseconds: 500_000_000)
        }

        guard let lastGym = dataManager.getLastUsedGym() else {
@@ -89,7 +89,23 @@ final class SessionIntentController {
    }

    private func logFailure(_ error: SessionIntentError, context: String) {
-        // Logging from intent context - errors are visible to user via dialog
+        // Log error for debugging
        print("SessionIntentError: \(error). Context: \(context)")
    }
+
+    /// Toggles the session state: ends active session if one exists, otherwise starts a new one.
+    func toggleSession() async throws -> (summary: SessionIntentSummary, wasStarted: Bool) {
+        // Wait for data to load
+        if dataManager.gyms.isEmpty {
+            try? await Task.sleep(nanoseconds: 500_000_000)
+        }
+
+        if dataManager.activeSession != nil {
+            let summary = try await endActiveSession()
+            return (summary, false)
+        } else {
+            let summary = try await startSessionWithLastUsedGym()
+            return (summary, true)
+        }
+    }
 }
--- a/ios/Ascently/AppIntents/StartLastGymSessionIntent.swift
+++ b/ios/Ascently/AppIntents/StartLastGymSessionIntent.swift
@@ -1,43 +0,0 @@
-import AppIntents
-import Foundation
-
-/// Starts a climbing session at the most recently visited gym.
-/// Exposed to Shortcuts so users can begin logging without opening the app.
-struct StartLastGymSessionIntent: AppIntent {
-
-    static var title: LocalizedStringResource {
-        "Start Last Gym Session"
-    }
-
-    static var description: IntentDescription {
-        IntentDescription(
-            "Begin a new climbing session using the most recent gym you visited in Ascently."
-        )
-    }
-
-    static var openAppWhenRun: Bool {
-        true
-    }
-
-    func perform() async throws -> some IntentResult & ProvidesDialog {
-        // Delay to ensure app has time to fully initialize if just launched
-        try? await Task.sleep(nanoseconds: 1_000_000_000)  // 1 second
-
-        let summary = try await SessionIntentController().startSessionWithLastUsedGym()
-
-        // Give Live Activity extra time to start
-        try? await Task.sleep(nanoseconds: 500_000_000)  // 0.5 seconds
-
-        return .result(
-            dialog: Self.successDialog(for: summary.gymName)
-        )
-    }
-
-    private static func successDialog(for gymName: String) -> IntentDialog {
-        IntentDialog("Session started at \(gymName). Have an awesome climb!")
-    }
-
-    static var parameterSummary: some ParameterSummary {
-        Summary("Start a session at my last gym")
-    }
-}
--- a/ios/Ascently/AppIntents/ToggleSessionIntent.swift
+++ b/ios/Ascently/AppIntents/ToggleSessionIntent.swift
@@ -0,0 +1,40 @@
+import AppIntents
+import Foundation
+
+/// Toggles the climbing session state: starts a session if none is active, or ends the current one.
+struct ToggleSessionIntent: AppIntent {
+
+    static var title: LocalizedStringResource {
+        "Toggle Climbing Session"
+    }
+
+    static var description: IntentDescription {
+        IntentDescription(
+            "Starts a new session at your last gym if you're not climbing, or ends your current session if you are."
+        )
+    }
+
+    static var openAppWhenRun: Bool {
+        false
+    }
+
+    func perform() async throws -> some IntentResult & ProvidesDialog {
+        // Wait for app initialization
+        try? await Task.sleep(nanoseconds: 1_000_000_000)
+
+        let controller = await SessionIntentController()
+        let (summary, wasStarted) = try await controller.toggleSession()
+
+        if wasStarted {
+            // Wait for Live Activity
+            try? await Task.sleep(nanoseconds: 500_000_000)
+            return .result(dialog: IntentDialog("Session started at \(summary.gymName). Have an awesome climb!"))
+        } else {
+            return .result(dialog: IntentDialog("Session at \(summary.gymName) ended. Nice work!"))
+        }
+    }
+
+    static var parameterSummary: some ParameterSummary {
+        Summary("Toggle my climbing session")
+    }
+}
--- a/ios/Ascently/AscentlyApp.swift
+++ b/ios/Ascently/AscentlyApp.swift
@@ -13,10 +13,13 @@ class AppDelegate: NSObject, UIApplicationDelegate {
 struct AscentlyApp: App {
    @UIApplicationDelegateAdaptor(AppDelegate.self) var appDelegate
    @Environment(\.scenePhase) private var scenePhase
+    @StateObject private var themeManager = ThemeManager()

    var body: some Scene {
        WindowGroup {
            ContentView()
+                .environmentObject(themeManager)
+                .tint(themeManager.accentColor)
        }
    }
 }
--- a/ios/Ascently/Components/CameraImagePicker.swift
+++ b/ios/Ascently/Components/CameraImagePicker.swift
@@ -1,52 +1,104 @@
 import SwiftUI
 import UIKit

+/// A native iOS camera picker presented from a hosting controller so it can
+/// respect all supported interface orientations. Present with `.fullScreenCover()`.
 struct CameraImagePicker: UIViewControllerRepresentable {
-    @Binding var isPresented: Bool
+    @Environment(\.dismiss) private var dismiss
    let onImageCaptured: (UIImage) -> Void

-    func makeUIViewController(context: Context) -> UIImagePickerController {
-        let picker = UIImagePickerController()
-        picker.delegate = context.coordinator
-        picker.sourceType = .camera
-        picker.cameraCaptureMode = .photo
-        picker.cameraDevice = .rear
-        picker.allowsEditing = false
-        return picker
+    func makeUIViewController(context: Context) -> CameraHostViewController {
+        let host = CameraHostViewController()
+        host.onImageCaptured = { image in
+            onImageCaptured(image)
+            dismiss()
+        }
+        host.onCancel = {
+            dismiss()
+        }
+        host.pickerDelegate = context.coordinator
+        context.coordinator.onImageCaptured = { image in
+            onImageCaptured(image)
+            dismiss()
+        }
+        context.coordinator.onCancel = {
+            dismiss()
+        }
+        return host
    }

-    func updateUIViewController(_ uiViewController: UIImagePickerController, context: Context) {
-        // Nothing here actually... Q_Q
+    func updateUIViewController(_ uiViewController: CameraHostViewController, context: Context) {
+        // No dynamic updates needed
    }

    func makeCoordinator() -> Coordinator {
-        Coordinator(self)
+        Coordinator()
    }

    class Coordinator: NSObject, UIImagePickerControllerDelegate, UINavigationControllerDelegate {
-        let parent: CameraImagePicker
-
-        init(_ parent: CameraImagePicker) {
-            self.parent = parent
-        }
+        var onImageCaptured: ((UIImage) -> Void)?
+        var onCancel: (() -> Void)?

        func imagePickerController(
            _ picker: UIImagePickerController,
            didFinishPickingMediaWithInfo info: [UIImagePickerController.InfoKey: Any]
        ) {
-            if let image = info[.originalImage] as? UIImage {
-                parent.onImageCaptured(image)
+            picker.dismiss(animated: true) {
+                if let image = info[.originalImage] as? UIImage {
+                    self.onImageCaptured?(image)
+                } else {
+                    self.onCancel?()
+                }
            }
-            parent.isPresented = false
        }

        func imagePickerControllerDidCancel(_ picker: UIImagePickerController) {
-            parent.isPresented = false
+            picker.dismiss(animated: true) {
+                self.onCancel?()
+            }
        }
    }
 }

-// Extension to check camera availability
+// MARK: - Hosting VC to own presentation/orientation
+final class CameraHostViewController: UIViewController {
+    var onImageCaptured: ((UIImage) -> Void)?
+    var onCancel: (() -> Void)?
+    weak var pickerDelegate: (UIImagePickerControllerDelegate & UINavigationControllerDelegate)?
+
+    private var didPresent = false
+
+    override func viewDidAppear(_ animated: Bool) {
+        super.viewDidAppear(animated)
+        presentIfNeeded()
+    }
+
+    private func presentIfNeeded() {
+        guard !didPresent, UIImagePickerController.isSourceTypeAvailable(.camera) else { return }
+        didPresent = true
+
+        let picker = UIImagePickerController()
+        picker.delegate = pickerDelegate
+        picker.sourceType = .camera
+        picker.cameraCaptureMode = .photo
+        picker.cameraDevice = .rear
+        picker.allowsEditing = false
+        picker.modalPresentationStyle = .fullScreen
+
+        present(picker, animated: true)
+    }
+
+    override var supportedInterfaceOrientations: UIInterfaceOrientationMask {
+        // Defer to app-supported orientations; returning .all allows rotation when permitted by the app
+        return .all
+    }
+
+    override var shouldAutorotate: Bool {
+        true
+    }
+}
+
+// MARK: - Camera Availability Check
 extension CameraImagePicker {
    static var isCameraAvailable: Bool {
        UIImagePickerController.isSourceTypeAvailable(.camera)
--- a/ios/Ascently/Components/PhotoOptionSheet.swift
+++ b/ios/Ascently/Components/PhotoOptionSheet.swift
@@ -8,6 +8,7 @@ struct PhotoOptionSheet: View {
    let onCameraSelected: () -> Void
    let onPhotoLibrarySelected: () -> Void
    let onDismiss: () -> Void
+    @EnvironmentObject var themeManager: ThemeManager

    var body: some View {
        NavigationView {
@@ -29,7 +30,7 @@ struct PhotoOptionSheet: View {
                        HStack {
                            Image(systemName: "photo.on.rectangle")
                                .font(.title2)
-                                .foregroundColor(.blue)
+                                .foregroundColor(themeManager.accentColor)
                            Text("Photo Library")
                                .font(.headline)
                            Spacer()
@@ -52,7 +53,7 @@ struct PhotoOptionSheet: View {
                        HStack {
                            Image(systemName: "camera.fill")
                                .font(.title2)
-                                .foregroundColor(.blue)
+                                .foregroundColor(themeManager.accentColor)
                            Text("Camera")
                                .font(.headline)
                            Spacer()
--- a/ios/Ascently/ContentView.swift
+++ b/ios/Ascently/ContentView.swift
@@ -44,6 +44,7 @@ struct ContentView: View {
                .tag(4)
        }
        .environmentObject(dataManager)
+        .environmentObject(MusicService.shared)
        .onChange(of: scenePhase) { oldPhase, newPhase in
            if newPhase == .active {
                // Add slight delay to ensure app is fully loaded
--- a/ios/Ascently/Info.plist
+++ b/ios/Ascently/Info.plist
@@ -15,5 +15,7 @@
 	<string>This app needs access to save your climbing workouts to Apple Health.</string>
 	<key>NSHealthUpdateUsageDescription</key>
 	<string>This app needs access to save your climbing workouts to Apple Health.</string>
+	<key>NSAppleMusicUsageDescription</key>
+	<string>This app (optionally) needs access to your music library to play your selected playlist during climbing sessions.</string>
 </dict>
 </plist>
--- a/ios/Ascently/Services/MusicService.swift
+++ b/ios/Ascently/Services/MusicService.swift
@@ -0,0 +1,197 @@
+import MusicKit
+import AVFoundation
+import SwiftUI
+import Combine
+
+@MainActor
+class MusicService: ObservableObject {
+    static let shared = MusicService()
+    
+    @Published var isAuthorized = false
+    @Published var playlists: MusicItemCollection<Playlist> = []
+    @Published var selectedPlaylistId: String? {
+        didSet {
+            UserDefaults.standard.set(selectedPlaylistId, forKey: "ascently_selected_playlist_id")
+        }
+    }
+    @Published var isMusicEnabled: Bool {
+        didSet {
+            UserDefaults.standard.set(isMusicEnabled, forKey: "ascently_music_enabled")
+            if !isMusicEnabled {
+                // Genuinely unsure what I want to do with this but we should account for it at some point
+            }
+        }
+    }
+    @Published var isAutoPlayEnabled: Bool {
+        didSet {
+            UserDefaults.standard.set(isAutoPlayEnabled, forKey: "ascently_music_autoplay_enabled")
+        }
+    }
+    @Published var isAutoStopEnabled: Bool {
+        didSet {
+            UserDefaults.standard.set(isAutoStopEnabled, forKey: "ascently_music_autostop_enabled")
+        }
+    }
+    @Published var isPlaying = false
+    
+    private var cancellables = Set<AnyCancellable>()
+    private var hasStartedSessionPlayback = false
+    private var currentPlaylistTrackIds: Set<MusicItemID> = []
+    
+    private init() {
+        self.selectedPlaylistId = UserDefaults.standard.string(forKey: "ascently_selected_playlist_id")
+        self.isMusicEnabled = UserDefaults.standard.bool(forKey: "ascently_music_enabled")
+        self.isAutoPlayEnabled = UserDefaults.standard.bool(forKey: "ascently_music_autoplay_enabled")
+        self.isAutoStopEnabled = UserDefaults.standard.bool(forKey: "ascently_music_autostop_enabled")
+        
+        if isMusicEnabled {
+            Task {
+                await checkAuthorizationStatus()
+            }
+        }
+        
+        setupObservers()
+    }
+    
+    private func setupObservers() {
+        SystemMusicPlayer.shared.state.objectWillChange
+            .sink { [weak self] _ in
+                self?.updatePlaybackStatus()
+            }
+            .store(in: &cancellables)
+            
+        SystemMusicPlayer.shared.queue.objectWillChange
+            .sink { [weak self] _ in
+                self?.checkQueueConsistency()
+            }
+            .store(in: &cancellables)
+    }
+    
+    private func updatePlaybackStatus() {
+        Task { @MainActor [weak self] in
+            self?.isPlaying = SystemMusicPlayer.shared.state.playbackStatus == .playing
+        }
+    }
+    
+    private func checkQueueConsistency() {
+        guard hasStartedSessionPlayback else { return }
+        
+        Task { @MainActor [weak self] in
+            guard let self = self else { return }
+            if let currentEntry = SystemMusicPlayer.shared.queue.currentEntry,
+               let item = currentEntry.item {
+                if !self.currentPlaylistTrackIds.isEmpty && !self.currentPlaylistTrackIds.contains(item.id) {
+                    self.hasStartedSessionPlayback = false
+                }
+            }
+        }
+    }
+    
+    func toggleMusicEnabled(_ enabled: Bool) {
+        isMusicEnabled = enabled
+        if enabled {
+            Task {
+                await checkAuthorizationStatus()
+            }
+        }
+    }
+    
+    func checkAuthorizationStatus() async {
+        let status = await MusicAuthorization.request()
+        self.isAuthorized = status == .authorized
+        if isAuthorized {
+            await fetchPlaylists()
+        }
+    }
+    
+    func fetchPlaylists() async {
+        guard isAuthorized else { return }
+        do {
+            var request = MusicLibraryRequest<Playlist>()
+            request.sort(by: \.name, ascending: true)
+            let response = try await request.response()
+            self.playlists = response.items
+        } catch {
+            print("Error fetching playlists: \(error)")
+        }
+    }
+    
+    func playSelectedPlaylistIfHeadphonesConnected() {
+        guard isMusicEnabled, isAutoPlayEnabled, let playlistId = selectedPlaylistId else { return }
+        
+        if isHeadphonesConnected() {
+            playPlaylist(id: playlistId)
+        }
+    }
+    
+    func resetSessionPlaybackState() {
+        hasStartedSessionPlayback = false
+        currentPlaylistTrackIds.removeAll()
+    }
+    
+    func playPlaylist(id: String) {
+        print("Attempting to play playlist \(id)")
+        Task {
+            do {
+                if playlists.isEmpty {
+                    await fetchPlaylists()
+                }
+                
+                var targetPlaylist: Playlist?
+                
+                if let playlist = playlists.first(where: { $0.id.rawValue == id }) {
+                    targetPlaylist = playlist
+                } else {
+                    var request = MusicLibraryRequest<Playlist>()
+                    request.filter(matching: \.id, equalTo: MusicItemID(id))
+                    let response = try await request.response()
+                    targetPlaylist = response.items.first
+                }
+                
+                if let playlist = targetPlaylist {
+                    let detailedPlaylist = try await playlist.with([.tracks])
+                    if let tracks = detailedPlaylist.tracks {
+                        self.currentPlaylistTrackIds = Set(tracks.map { $0.id })
+                    }
+                    
+                    SystemMusicPlayer.shared.queue = [playlist]
+                    try await SystemMusicPlayer.shared.play()
+                    hasStartedSessionPlayback = true
+                }
+            } catch {
+                print("Error playing playlist: \(error)")
+            }
+        }
+    }
+    
+    func stopPlaybackIfEnabled() {
+        guard isMusicEnabled, isAutoStopEnabled else { return }
+        SystemMusicPlayer.shared.stop()
+    }
+    
+    func togglePlayback() {
+        Task {
+            if isPlaying {
+                SystemMusicPlayer.shared.pause()
+            } else {
+                if let playlistId = selectedPlaylistId, !hasStartedSessionPlayback {
+                    playPlaylist(id: playlistId)
+                } else {
+                    try? await SystemMusicPlayer.shared.play()
+                }
+            }
+        }
+    }
+    
+    private func isHeadphonesConnected() -> Bool {
+        let route = AVAudioSession.sharedInstance().currentRoute
+        return route.outputs.contains { port in
+            port.portType == .headphones ||
+            port.portType == .bluetoothA2DP ||
+            port.portType == .bluetoothLE ||
+            port.portType == .bluetoothHFP ||
+            port.portType == .usbAudio ||
+            port.portType == .airPlay
+        }
+    }
+}
--- a/ios/Ascently/Services/Sync/ServerSyncProvider.swift
+++ b/ios/Ascently/Services/Sync/ServerSyncProvider.swift
--- a/ios/Ascently/Services/Sync/SyncMerger.swift
+++ b/ios/Ascently/Services/Sync/SyncMerger.swift
@@ -0,0 +1,181 @@
+import Foundation
+
+struct SyncMerger {
+    private static let logTag = "SyncMerger"
+    
+    static func mergeDataSafely(
+        localBackup: ClimbDataBackup,
+        serverBackup: ClimbDataBackup,
+        dataManager: ClimbingDataManager,
+        imagePathMapping: [String: String]
+    ) throws -> (gyms: [Gym], problems: [Problem], sessions: [ClimbSession], attempts: [Attempt], uniqueDeletions: [DeletedItem]) {
+        
+        // Merge deletion lists first to prevent resurrection of deleted items
+        let localDeletions = dataManager.getDeletedItems()
+        let allDeletions = localDeletions + serverBackup.deletedItems
+        let uniqueDeletions = Array(Set(allDeletions))
+        
+        AppLogger.info("Merging gyms...", tag: logTag)
+        let mergedGyms = mergeGyms(
+            local: dataManager.gyms,
+            server: serverBackup.gyms,
+            deletedItems: uniqueDeletions)
+        
+        AppLogger.info("Merging problems...", tag: logTag)
+        let mergedProblems = try mergeProblems(
+            local: dataManager.problems,
+            server: serverBackup.problems,
+            imagePathMapping: imagePathMapping,
+            deletedItems: uniqueDeletions)
+        
+        AppLogger.info("Merging sessions...", tag: logTag)
+        let mergedSessions = try mergeSessions(
+            local: dataManager.sessions,
+            server: serverBackup.sessions,
+            deletedItems: uniqueDeletions)
+        
+        AppLogger.info("Merging attempts...", tag: logTag)
+        let mergedAttempts = try mergeAttempts(
+            local: dataManager.attempts,
+            server: serverBackup.attempts,
+            deletedItems: uniqueDeletions)
+            
+        return (mergedGyms, mergedProblems, mergedSessions, mergedAttempts, uniqueDeletions)
+    }
+    
+    private static func mergeGyms(local: [Gym], server: [BackupGym], deletedItems: [DeletedItem]) -> [Gym] {
+        var merged = local
+        let deletedGymIds = Set(deletedItems.filter { $0.type == "gym" }.map { $0.id })
+        let localGymIds = Set(local.map { $0.id.uuidString })
+        
+        merged.removeAll { deletedGymIds.contains($0.id.uuidString) }
+        
+        // Add new items from server (excluding deleted ones)
+        for serverGym in server {
+            if let serverGymConverted = try? serverGym.toGym() {
+                let localHasGym = localGymIds.contains(serverGym.id)
+                let isDeleted = deletedGymIds.contains(serverGym.id)
+                
+                if !localHasGym && !isDeleted {
+                    merged.append(serverGymConverted)
+                }
+            }
+        }
+        
+        return merged
+    }
+    
+    private static func mergeProblems(
+        local: [Problem],
+        server: [BackupProblem],
+        imagePathMapping: [String: String],
+        deletedItems: [DeletedItem]
+    ) throws -> [Problem] {
+        var merged = local
+        let deletedProblemIds = Set(deletedItems.filter { $0.type == "problem" }.map { $0.id })
+        let localProblemIds = Set(local.map { $0.id.uuidString })
+        
+        merged.removeAll { deletedProblemIds.contains($0.id.uuidString) }
+        
+        for serverProblem in server {
+            let localHasProblem = localProblemIds.contains(serverProblem.id)
+            let isDeleted = deletedProblemIds.contains(serverProblem.id)
+            
+            if !localHasProblem && !isDeleted {
+                var problemToAdd = serverProblem
+                
+                if !imagePathMapping.isEmpty, let imagePaths = serverProblem.imagePaths, !imagePaths.isEmpty {
+                    let updatedImagePaths = imagePaths.compactMap { oldPath in
+                        imagePathMapping[oldPath] ?? oldPath
+                    }
+                    if updatedImagePaths != imagePaths {
+                        problemToAdd = BackupProblem(
+                            id: serverProblem.id,
+                            gymId: serverProblem.gymId,
+                            name: serverProblem.name,
+                            description: serverProblem.description,
+                            climbType: serverProblem.climbType,
+                            difficulty: serverProblem.difficulty,
+                            tags: serverProblem.tags,
+                            location: serverProblem.location,
+                            imagePaths: updatedImagePaths,
+                            isActive: serverProblem.isActive,
+                            dateSet: serverProblem.dateSet,
+                            notes: serverProblem.notes,
+                            createdAt: serverProblem.createdAt,
+                            updatedAt: serverProblem.updatedAt
+                        )
+                    }
+                }
+                
+                if let serverProblemConverted = try? problemToAdd.toProblem() {
+                    merged.append(serverProblemConverted)
+                }
+            }
+        }
+        
+        return merged
+    }
+    
+    private static func mergeSessions(
+        local: [ClimbSession], server: [BackupClimbSession], deletedItems: [DeletedItem]
+    ) throws -> [ClimbSession] {
+        var merged = local
+        let deletedSessionIds = Set(deletedItems.filter { $0.type == "session" }.map { $0.id })
+        let localSessionIds = Set(local.map { $0.id.uuidString })
+        
+        merged.removeAll { session in
+            deletedSessionIds.contains(session.id.uuidString) && session.status != .active
+        }
+        
+        for serverSession in server {
+            let localHasSession = localSessionIds.contains(serverSession.id)
+            let isDeleted = deletedSessionIds.contains(serverSession.id)
+            
+            if !localHasSession && !isDeleted {
+                if let serverSessionConverted = try? serverSession.toClimbSession() {
+                    merged.append(serverSessionConverted)
+                }
+            }
+        }
+        
+        return merged
+    }
+    
+    private static func mergeAttempts(
+        local: [Attempt], server: [BackupAttempt], deletedItems: [DeletedItem]
+    ) throws -> [Attempt] {
+        var merged = local
+        let deletedAttemptIds = Set(deletedItems.filter { $0.type == "attempt" }.map { $0.id })
+        let localAttemptIds = Set(local.map { $0.id.uuidString })
+        
+        // Get active session IDs to protect their attempts
+        let activeSessionIds = Set(
+            local.compactMap { attempt in
+                return attempt.sessionId
+            }.filter { sessionId in
+                // Check if this session ID belongs to an active session
+                // For now, we'll be conservative and not delete attempts during merge
+                return true
+            })
+        
+        // Remove items that were deleted on other devices (but be conservative with attempts)
+        merged.removeAll { attempt in
+            deletedAttemptIds.contains(attempt.id.uuidString)
+                && !activeSessionIds.contains(attempt.sessionId)
+        }
+        
+        for serverAttempt in server {
+            let localHasAttempt = localAttemptIds.contains(serverAttempt.id)
+            let isDeleted = deletedAttemptIds.contains(serverAttempt.id)
+            
+            if !localHasAttempt && !isDeleted {
+                if let serverAttemptConverted = try? serverAttempt.toAttempt() {
+                    merged.append(serverAttemptConverted)
+                }
+            }
+        }
+        
+        return merged
+    }
+}
--- a/ios/Ascently/Services/Sync/SyncProvider.swift
+++ b/ios/Ascently/Services/Sync/SyncProvider.swift
@@ -0,0 +1,73 @@
+import Foundation
+
+enum SyncProviderType: String, CaseIterable, Identifiable {
+    case none
+    case server
+    case iCloud
+    
+    var id: String { rawValue }
+    var displayName: String {
+        switch self {
+        case .none: return "None"
+        case .server: return "Self-Hosted Server"
+        case .iCloud: return "iCloud"
+        }
+    }
+}
+
+protocol SyncProvider {
+    var type: SyncProviderType { get }
+    var isConfigured: Bool { get }
+    var isConnected: Bool { get }
+    
+    func sync(dataManager: ClimbingDataManager) async throws
+    func testConnection() async throws
+    func disconnect()
+}
+
+enum SyncError: LocalizedError {
+    case notConfigured
+    case notConnected
+    case invalidURL
+    case invalidResponse
+    case unauthorized
+    case badRequest
+    case serverError(Int)
+    case decodingError(Error)
+    case exportFailed
+    case importFailed(Error)
+    case imageNotFound
+    case imageUploadFailed
+    case providerError(String)
+
+    var errorDescription: String? {
+        switch self {
+        case .notConfigured:
+            return "Sync server not configured. Please set server URL and auth token."
+        case .notConnected:
+            return "Not connected to sync server. Please test connection first."
+        case .invalidURL:
+            return "Invalid server URL."
+        case .invalidResponse:
+            return "Invalid response from server."
+        case .unauthorized:
+            return "Authentication failed. Check your auth token."
+        case .badRequest:
+            return "Bad request. Check your data format."
+        case .serverError(let code):
+            return "Server error (code \(code))."
+        case .decodingError(let error):
+            return "Failed to decode response: \(error.localizedDescription)"
+        case .exportFailed:
+            return "Failed to export local data."
+        case .importFailed(let error):
+            return "Failed to import data: \(error.localizedDescription)"
+        case .imageNotFound:
+            return "Image not found on server."
+        case .imageUploadFailed:
+            return "Failed to upload image to server."
+        case .providerError(let message):
+            return "Sync provider error: \(message)"
+        }
+    }
+}
--- a/ios/Ascently/Services/SyncService.swift
+++ b/ios/Ascently/Services/SyncService.swift
--- a/ios/Ascently/Utils/ThemeManager.swift
+++ b/ios/Ascently/Utils/ThemeManager.swift
@@ -0,0 +1,77 @@
+import SwiftUI
+import Combine
+
+class ThemeManager: ObservableObject {
+    @Published var accentColor: Color = .blue {
+        didSet {
+            saveColor()
+        }
+    }
+    
+    private let userDefaultsKey = "accentColorData"
+    
+    init() {
+        loadColor()
+    }
+    
+    private func loadColor() {
+        guard let data = UserDefaults.standard.data(forKey: userDefaultsKey) else {
+            self.accentColor = .blue
+            return
+        }
+        
+        do {
+            if let uiColor = try NSKeyedUnarchiver.unarchivedObject(ofClass: UIColor.self, from: data) {
+                self.accentColor = Color(uiColor)
+            }
+        } catch {
+            print("Failed to load accent color: \(error)")
+            self.accentColor = .blue
+        }
+    }
+    
+    private func saveColor() {
+        do {
+            let uiColor = UIColor(accentColor)
+            let data = try NSKeyedArchiver.archivedData(withRootObject: uiColor, requiringSecureCoding: false)
+            UserDefaults.standard.set(data, forKey: userDefaultsKey)
+        } catch {
+            print("Failed to save accent color: \(error)")
+        }
+    }
+    
+    func resetToDefault() {
+        accentColor = .blue
+    }
+    
+    // Curated list of preset colors that maintain good contrast
+    static let presetColors: [Color] = [
+        .blue,      // Default Blue
+        .purple,    // Purple
+        .pink,      // Pink
+        .red,       // Red
+        .orange,    // Orange
+        .green,     // Green
+        .teal,      // Teal
+        .indigo,    // Indigo
+        .mint,      // Mint
+        Color(uiColor: .systemBrown), // Brown
+        Color(uiColor: .systemCyan)   // Cyan
+    ]
+    
+    var contrastingTextColor: Color {
+        let uiColor = UIColor(accentColor)
+        var red: CGFloat = 0
+        var green: CGFloat = 0
+        var blue: CGFloat = 0
+        var alpha: CGFloat = 0
+        
+        uiColor.getRed(&red, green: &green, blue: &blue, alpha: &alpha)
+        
+        // Calculate relative luminance
+        let luminance = 0.299 * red + 0.587 * green + 0.114 * blue
+        
+        // Return black for light colors, white for dark colors
+        return luminance > 0.5 ? .black : .white
+    }
+}
--- a/ios/Ascently/ViewModels/ClimbingDataManager.swift
+++ b/ios/Ascently/ViewModels/ClimbingDataManager.swift
@@ -38,6 +38,7 @@ class ClimbingDataManager: ObservableObject {

    let syncService = SyncService()
    let healthKitService = HealthKitService.shared
+    let musicService = MusicService.shared

    @Published var isSyncing = false
    private enum Keys {
@@ -437,13 +438,15 @@ class ClimbingDataManager: ObservableObject {
        saveSessions()
        DataStateManager.shared.updateDataState()

-        // MARK: - Start Live Activity for new session
        if let gym = gym(withId: gymId) {
            await LiveActivityManager.shared.startLiveActivity(
                for: newSession,
                gymName: gym.name)
        }

+        musicService.resetSessionPlaybackState()
+        musicService.playSelectedPlaylistIfHeadphonesConnected()
+
        if healthKitService.isEnabled {
            do {
                try await healthKitService.startWorkout(
@@ -488,8 +491,12 @@ class ClimbingDataManager: ObservableObject {
        // Trigger auto-sync if enabled
        syncService.triggerAutoSync(dataManager: self)

-        // MARK: - End Live Activity after session ends
        await LiveActivityManager.shared.endLiveActivity()
+        
+        if UserDefaults.standard.bool(forKey: "isAutoStopMusicEnabled") {
+            musicService.stopPlaybackIfEnabled()
+        }
+        musicService.stopPlaybackIfEnabled()

        if healthKitService.isEnabled {
            do {
--- a/ios/Ascently/ViewModels/LiveActivityManager.swift
+++ b/ios/Ascently/ViewModels/LiveActivityManager.swift
@@ -207,7 +207,7 @@ final class LiveActivityManager {
    func startHealthChecks() {
        stopHealthChecks()  // Stop any existing timer

-        AppLogger.debug("🩺 Starting Live Activity health checks", tag: Self.logTag)
+        AppLogger.debug("Starting Live Activity health checks", tag: Self.logTag)
        healthCheckTimer = Timer.scheduledTimer(withTimeInterval: 30.0, repeats: true) {
            [weak self] _ in
            Task { @MainActor [weak self] in
@@ -233,7 +233,7 @@ final class LiveActivityManager {
        // Only perform health check if it's been at least 25 seconds
        guard timeSinceLastCheck >= 25 else { return }

-        AppLogger.debug("🩺 Performing Live Activity health check", tag: Self.logTag)
+        AppLogger.debug("Performing Live Activity health check", tag: Self.logTag)
        lastHealthCheck = now

        let activities = Activity<SessionActivityAttributes>.activities
--- a/ios/Ascently/Views/AddEdit/AddAttemptView.swift
+++ b/ios/Ascently/Views/AddEdit/AddAttemptView.swift
@@ -5,6 +5,7 @@ struct AddAttemptView: View {
    let session: ClimbSession
    let gym: Gym
    @EnvironmentObject var dataManager: ClimbingDataManager
+    @EnvironmentObject var themeManager: ThemeManager
    @Environment(\.dismiss) private var dismiss

    @State private var selectedProblem: Problem?
@@ -25,19 +26,19 @@ struct AddAttemptView: View {

    enum SheetType: Identifiable {
        case photoOptions
-        case camera

        var id: Int {
            switch self {
            case .photoOptions: return 0
-            case .camera: return 1
            }
        }
    }

    @State private var activeSheet: SheetType?
+    @State private var showCamera = false
    @State private var showPhotoPicker = false
    @State private var isPhotoPickerActionPending = false
+    @State private var isCameraActionPending = false

    private var activeProblems: [Problem] {
        dataManager.activeProblems(forGym: gym.id)
@@ -109,6 +110,11 @@ struct AddAttemptView: View {
        .sheet(
            item: $activeSheet,
            onDismiss: {
+                if isCameraActionPending {
+                    showCamera = true
+                    isCameraActionPending = false
+                    return
+                }
                if isPhotoPickerActionPending {
                    showPhotoPicker = true
                    isPhotoPickerActionPending = false
@@ -122,7 +128,8 @@ struct AddAttemptView: View {
                    imageData: $imageData,
                    maxImages: 5,
                    onCameraSelected: {
-                        activeSheet = .camera
+                        isCameraActionPending = true
+                        activeSheet = nil
                    },
                    onPhotoLibrarySelected: {
                        isPhotoPickerActionPending = true
@@ -131,16 +138,12 @@ struct AddAttemptView: View {
                        activeSheet = nil
                    }
                )
-            case .camera:
-                CameraImagePicker(
-                    isPresented: Binding(
-                        get: { activeSheet == .camera },
-                        set: { if !$0 { activeSheet = nil } }
-                    )
-                ) { capturedImage in
-                    if let jpegData = capturedImage.jpegData(compressionQuality: 0.8) {
-                        imageData.append(jpegData)
-                    }
+            }
+        }
+        .fullScreenCover(isPresented: $showCamera) {
+            CameraImagePicker { capturedImage in
+                if let jpegData = capturedImage.jpegData(compressionQuality: 0.8) {
+                    imageData.append(jpegData)
                }
            }
        }
@@ -158,6 +161,7 @@ struct AddAttemptView: View {
                        showingCreateProblem = true
                    }
                    .buttonStyle(.borderedProminent)
+                    .tint(themeManager.accentColor)
                }
                .padding(.vertical, 8)
            } else {
@@ -179,7 +183,7 @@ struct AddAttemptView: View {
                Button("Create New Problem") {
                    showingCreateProblem = true
                }
-                .foregroundColor(.blue)
+                .foregroundColor(themeManager.accentColor)
            }
        }
    }
@@ -198,7 +202,7 @@ struct AddAttemptView: View {
                    selectedPhotos = []
                    imageData = []
                }
-                .foregroundColor(.blue)
+                .foregroundColor(themeManager.accentColor)
            }
        }

@@ -213,7 +217,7 @@ struct AddAttemptView: View {
                    Spacer()
                    if selectedClimbType == climbType {
                        Image(systemName: "checkmark.circle.fill")
-                            .foregroundColor(.blue)
+                            .foregroundColor(themeManager.accentColor)
                    } else {
                        Image(systemName: "circle")
                            .foregroundColor(.gray)
@@ -238,7 +242,7 @@ struct AddAttemptView: View {
                        Spacer()
                        if selectedDifficultySystem == system {
                            Image(systemName: "checkmark.circle.fill")
-                                .foregroundColor(.blue)
+                                .foregroundColor(themeManager.accentColor)
                        } else {
                            Image(systemName: "circle")
                                .foregroundColor(.gray)
@@ -272,7 +276,7 @@ struct AddAttemptView: View {
                                }
                                .buttonStyle(.bordered)
                                .controlSize(.small)
-                                .tint(newProblemGrade == grade ? .blue : .gray)
+                                .tint(newProblemGrade == grade ? themeManager.accentColor : .gray)
                            }
                        }
                        .padding(.horizontal, 1)
@@ -287,12 +291,12 @@ struct AddAttemptView: View {
            }) {
                HStack {
                    Image(systemName: "camera.fill")
-                        .foregroundColor(.blue)
+                        .foregroundColor(themeManager.accentColor)
                        .font(.title2)
                    VStack(alignment: .leading, spacing: 2) {
                        Text("Add Photos")
                            .font(.headline)
-                            .foregroundColor(.blue)
+                            .foregroundColor(themeManager.accentColor)
                        Text("\(imageData.count) of 5 photos added")
                            .font(.caption)
                            .foregroundColor(.secondary)
@@ -353,7 +357,7 @@ struct AddAttemptView: View {
                    Spacer()
                    if selectedResult == result {
                        Image(systemName: "checkmark.circle.fill")
-                            .foregroundColor(.blue)
+                            .foregroundColor(themeManager.accentColor)
                    } else {
                        Image(systemName: "circle")
                            .foregroundColor(.gray)
@@ -529,6 +533,7 @@ struct ProblemSelectionRow: View {
    let problem: Problem
    let isSelected: Bool
    let action: () -> Void
+    @EnvironmentObject var themeManager: ThemeManager

    var body: some View {
        HStack {
@@ -539,7 +544,7 @@ struct ProblemSelectionRow: View {

                Text("\(problem.difficulty.system.displayName): \(problem.difficulty.grade)")
                    .font(.subheadline)
-                    .foregroundColor(.blue)
+                    .foregroundColor(themeManager.accentColor)

                if let location = problem.location {
                    Text(location)
@@ -552,7 +557,7 @@ struct ProblemSelectionRow: View {

            if isSelected {
                Image(systemName: "checkmark.circle.fill")
-                    .foregroundColor(.blue)
+                    .foregroundColor(themeManager.accentColor)
            } else {
                Image(systemName: "circle")
                    .foregroundColor(.gray)
@@ -569,6 +574,7 @@ struct ProblemSelectionCard: View {
    let isSelected: Bool
    let action: () -> Void
    @State private var showingExpandedView = false
+    @EnvironmentObject var themeManager: ThemeManager

    var body: some View {
        VStack(spacing: 8) {
@@ -594,7 +600,7 @@ struct ProblemSelectionCard: View {
                        if isSelected {
                            Image(systemName: "checkmark.circle.fill")
                                .foregroundColor(.white)
-                                .background(Circle().fill(.blue))
+                                .background(Circle().fill(themeManager.accentColor))
                                .font(.title3)
                        }
                    }
@@ -634,7 +640,7 @@ struct ProblemSelectionCard: View {
                Text(problem.difficulty.grade)
                    .font(.caption2)
                    .fontWeight(.bold)
-                    .foregroundColor(.blue)
+                    .foregroundColor(themeManager.accentColor)

                if let location = problem.location {
                    Text(location)
@@ -648,8 +654,8 @@ struct ProblemSelectionCard: View {
        .padding(8)
        .background(
            RoundedRectangle(cornerRadius: 12)
-                .fill(isSelected ? .blue.opacity(0.1) : .gray.opacity(0.05))
-                .stroke(isSelected ? .blue : .clear, lineWidth: 2)
+                .fill(isSelected ? themeManager.accentColor.opacity(0.1) : .gray.opacity(0.05))
+                .stroke(isSelected ? themeManager.accentColor : .clear, lineWidth: 2)
        )
        .contentShape(Rectangle())
        .onTapGesture {
@@ -668,6 +674,7 @@ struct ProblemSelectionCard: View {
 struct ProblemExpandedView: View {
    let problem: Problem
    @Environment(\.dismiss) private var dismiss
+    @EnvironmentObject var themeManager: ThemeManager
    @State private var selectedImageIndex = 0

    var body: some View {
@@ -696,7 +703,7 @@ struct ProblemExpandedView: View {
                            Text(problem.difficulty.grade)
                                .font(.title3)
                                .fontWeight(.bold)
-                                .foregroundColor(.blue)
+                                .foregroundColor(themeManager.accentColor)

                            Text(problem.climbType.displayName)
                                .font(.subheadline)
@@ -724,9 +731,9 @@ struct ProblemExpandedView: View {
                                            .padding(.vertical, 4)
                                            .background(
                                                RoundedRectangle(cornerRadius: 8)
-                                                    .fill(.blue.opacity(0.1))
+                                                    .fill(themeManager.accentColor.opacity(0.1))
                                            )
-                                            .foregroundColor(.blue)
+                                            .foregroundColor(themeManager.accentColor)
                                    }
                                }
                                .padding(.horizontal)
@@ -752,6 +759,7 @@ struct ProblemExpandedView: View {
 struct EditAttemptView: View {
    let attempt: Attempt
    @EnvironmentObject var dataManager: ClimbingDataManager
+    @EnvironmentObject var themeManager: ThemeManager
    @Environment(\.dismiss) private var dismiss

    @State private var selectedProblem: Problem?
@@ -772,19 +780,19 @@ struct EditAttemptView: View {

    enum SheetType: Identifiable {
        case photoOptions
-        case camera

        var id: Int {
            switch self {
            case .photoOptions: return 0
-            case .camera: return 1
            }
        }
    }

    @State private var activeSheet: SheetType?
+    @State private var showCamera = false
    @State private var showPhotoPicker = false
    @State private var isPhotoPickerActionPending = false
+    @State private var isCameraActionPending = false

    private var availableProblems: [Problem] {
        guard let session = dataManager.session(withId: attempt.sessionId) else {
@@ -877,6 +885,11 @@ struct EditAttemptView: View {
        .sheet(
            item: $activeSheet,
            onDismiss: {
+                if isCameraActionPending {
+                    showCamera = true
+                    isCameraActionPending = false
+                    return
+                }
                if isPhotoPickerActionPending {
                    showPhotoPicker = true
                    isPhotoPickerActionPending = false
@@ -890,7 +903,8 @@ struct EditAttemptView: View {
                    imageData: $imageData,
                    maxImages: 5,
                    onCameraSelected: {
-                        activeSheet = .camera
+                        isCameraActionPending = true
+                        activeSheet = nil
                    },
                    onPhotoLibrarySelected: {
                        isPhotoPickerActionPending = true
@@ -899,16 +913,12 @@ struct EditAttemptView: View {
                        activeSheet = nil
                    }
                )
-            case .camera:
-                CameraImagePicker(
-                    isPresented: Binding(
-                        get: { activeSheet == .camera },
-                        set: { if !$0 { activeSheet = nil } }
-                    )
-                ) { capturedImage in
-                    if let jpegData = capturedImage.jpegData(compressionQuality: 0.8) {
-                        imageData.append(jpegData)
-                    }
+            }
+        }
+        .fullScreenCover(isPresented: $showCamera) {
+            CameraImagePicker { capturedImage in
+                if let jpegData = capturedImage.jpegData(compressionQuality: 0.8) {
+                    imageData.append(jpegData)
                }
            }
        }
@@ -926,6 +936,7 @@ struct EditAttemptView: View {
                        showingCreateProblem = true
                    }
                    .buttonStyle(.borderedProminent)
+                    .tint(themeManager.accentColor)
                }
                .padding(.vertical, 8)
            } else {
@@ -947,7 +958,7 @@ struct EditAttemptView: View {
                Button("Create New Problem") {
                    showingCreateProblem = true
                }
-                .foregroundColor(.blue)
+                .foregroundColor(themeManager.accentColor)
            }
        }
    }
@@ -966,7 +977,7 @@ struct EditAttemptView: View {
                    selectedPhotos = []
                    imageData = []
                }
-                .foregroundColor(.blue)
+                .foregroundColor(themeManager.accentColor)
            }
        }

@@ -981,7 +992,7 @@ struct EditAttemptView: View {
                    Spacer()
                    if selectedClimbType == climbType {
                        Image(systemName: "checkmark.circle.fill")
-                            .foregroundColor(.blue)
+                            .foregroundColor(themeManager.accentColor)
                    } else {
                        Image(systemName: "circle")
                            .foregroundColor(.gray)
@@ -1006,7 +1017,7 @@ struct EditAttemptView: View {
                        Spacer()
                        if selectedDifficultySystem == system {
                            Image(systemName: "checkmark.circle.fill")
-                                .foregroundColor(.blue)
+                                .foregroundColor(themeManager.accentColor)
                        } else {
                            Image(systemName: "circle")
                                .foregroundColor(.gray)
@@ -1040,7 +1051,7 @@ struct EditAttemptView: View {
                                }
                                .buttonStyle(.bordered)
                                .controlSize(.small)
-                                .tint(newProblemGrade == grade ? .blue : .gray)
+                                .tint(newProblemGrade == grade ? themeManager.accentColor : .gray)
                            }
                        }
                        .padding(.horizontal, 1)
@@ -1055,12 +1066,12 @@ struct EditAttemptView: View {
            }) {
                HStack {
                    Image(systemName: "camera.fill")
-                        .foregroundColor(.blue)
+                        .foregroundColor(themeManager.accentColor)
                        .font(.title2)
                    VStack(alignment: .leading, spacing: 2) {
                        Text("Add Photos")
                            .font(.headline)
-                            .foregroundColor(.blue)
+                            .foregroundColor(themeManager.accentColor)
                        Text("\(imageData.count) of 5 photos added")
                            .font(.caption)
                            .foregroundColor(.secondary)
@@ -1121,7 +1132,7 @@ struct EditAttemptView: View {
                    Spacer()
                    if selectedResult == result {
                        Image(systemName: "checkmark.circle.fill")
-                            .foregroundColor(.blue)
+                            .foregroundColor(themeManager.accentColor)
                    } else {
                        Image(systemName: "circle")
                            .foregroundColor(.gray)
--- a/ios/Ascently/Views/AddEdit/AddEditGymView.swift
+++ b/ios/Ascently/Views/AddEdit/AddEditGymView.swift
@@ -3,6 +3,7 @@ import SwiftUI
 struct AddEditGymView: View {
    let gymId: UUID?
    @EnvironmentObject var dataManager: ClimbingDataManager
+    @EnvironmentObject var themeManager: ThemeManager
    @Environment(\.dismiss) private var dismiss

    @State private var name = ""
@@ -83,7 +84,7 @@ struct AddEditGymView: View {
                    Spacer()
                    if selectedClimbTypes.contains(climbType) {
                        Image(systemName: "checkmark.circle.fill")
-                            .foregroundColor(.blue)
+                            .foregroundColor(themeManager.accentColor)
                    } else {
                        Image(systemName: "circle")
                            .foregroundColor(.gray)
@@ -115,7 +116,7 @@ struct AddEditGymView: View {
                        Spacer()
                        if selectedDifficultySystems.contains(system) {
                            Image(systemName: "checkmark.circle.fill")
-                                .foregroundColor(.blue)
+                                .foregroundColor(themeManager.accentColor)
                        } else {
                            Image(systemName: "circle")
                                .foregroundColor(.gray)
--- a/ios/Ascently/Views/AddEdit/AddEditProblemView.swift
+++ b/ios/Ascently/Views/AddEdit/AddEditProblemView.swift
@@ -5,6 +5,7 @@ struct AddEditProblemView: View {
    let problemId: UUID?
    let gymId: UUID?
    @EnvironmentObject var dataManager: ClimbingDataManager
+    @EnvironmentObject var themeManager: ThemeManager
    @Environment(\.dismiss) private var dismiss

    @State private var selectedGym: Gym?
@@ -24,19 +25,19 @@ struct AddEditProblemView: View {
    @State private var isEditing = false
    enum SheetType: Identifiable {
        case photoOptions
-        case camera

        var id: Int {
            switch self {
            case .photoOptions: return 0
-            case .camera: return 1
            }
        }
    }

    @State private var activeSheet: SheetType?
+    @State private var showCamera = false
    @State private var showPhotoPicker = false
    @State private var isPhotoPickerActionPending = false
+    @State private var isCameraActionPending = false

    private var existingProblem: Problem? {
        guard let problemId = problemId else { return nil }
@@ -119,6 +120,11 @@ struct AddEditProblemView: View {
        .sheet(
            item: $activeSheet,
            onDismiss: {
+                if isCameraActionPending {
+                    showCamera = true
+                    isCameraActionPending = false
+                    return
+                }
                if isPhotoPickerActionPending {
                    showPhotoPicker = true
                    isPhotoPickerActionPending = false
@@ -132,7 +138,8 @@ struct AddEditProblemView: View {
                    imageData: $imageData,
                    maxImages: 5,
                    onCameraSelected: {
-                        activeSheet = .camera
+                        isCameraActionPending = true
+                        activeSheet = nil
                    },
                    onPhotoLibrarySelected: {
                        isPhotoPickerActionPending = true
@@ -141,16 +148,12 @@ struct AddEditProblemView: View {
                        activeSheet = nil
                    }
                )
-            case .camera:
-                CameraImagePicker(
-                    isPresented: Binding(
-                        get: { activeSheet == .camera },
-                        set: { if !$0 { activeSheet = nil } }
-                    )
-                ) { capturedImage in
-                    if let jpegData = capturedImage.jpegData(compressionQuality: 0.8) {
-                        imageData.append(jpegData)
-                    }
+            }
+        }
+        .fullScreenCover(isPresented: $showCamera) {
+            CameraImagePicker { capturedImage in
+                if let jpegData = capturedImage.jpegData(compressionQuality: 0.8) {
+                    imageData.append(jpegData)
                }
            }
        }
@@ -192,7 +195,7 @@ struct AddEditProblemView: View {

                        if selectedGym?.id == gym.id {
                            Image(systemName: "checkmark.circle.fill")
-                                .foregroundColor(.blue)
+                                .foregroundColor(themeManager.accentColor)
                        }
                    }
                    .contentShape(Rectangle())
@@ -235,7 +238,7 @@ struct AddEditProblemView: View {
                        Spacer()
                        if selectedClimbType == climbType {
                            Image(systemName: "checkmark.circle.fill")
-                                .foregroundColor(.blue)
+                                .foregroundColor(themeManager.accentColor)
                        } else {
                            Image(systemName: "circle")
                                .foregroundColor(.gray)
@@ -264,7 +267,7 @@ struct AddEditProblemView: View {
                        Spacer()
                        if selectedDifficultySystem == system {
                            Image(systemName: "checkmark.circle.fill")
-                                .foregroundColor(.blue)
+                                .foregroundColor(themeManager.accentColor)
                        } else {
                            Image(systemName: "circle")
                                .foregroundColor(.gray)
@@ -337,7 +340,7 @@ struct AddEditProblemView: View {
                } else {
                    Text("Selected: \(difficultyGrade)")
                        .font(.caption)
-                        .foregroundColor(.blue)
+                        .foregroundColor(themeManager.accentColor)
                }
            }
        }
@@ -372,12 +375,12 @@ struct AddEditProblemView: View {
            }) {
                HStack {
                    Image(systemName: "camera.fill")
-                        .foregroundColor(.blue)
+                        .foregroundColor(themeManager.accentColor)
                        .font(.title2)
                    VStack(alignment: .leading, spacing: 2) {
                        Text("Add Photos")
                            .font(.headline)
-                            .foregroundColor(.blue)
+                            .foregroundColor(themeManager.accentColor)
                        Text("\(imageData.count) of 5 photos added")
                            .font(.caption)
                            .foregroundColor(.secondary)
--- a/ios/Ascently/Views/AddEdit/AddEditSessionView.swift
+++ b/ios/Ascently/Views/AddEdit/AddEditSessionView.swift
@@ -3,6 +3,7 @@ import SwiftUI
 struct AddEditSessionView: View {
    let sessionId: UUID?
    @EnvironmentObject var dataManager: ClimbingDataManager
+    @EnvironmentObject var themeManager: ThemeManager
    @Environment(\.dismiss) private var dismiss

    @State private var selectedGym: Gym?
@@ -71,7 +72,7 @@ struct AddEditSessionView: View {

                        if selectedGym?.id == gym.id {
                            Image(systemName: "checkmark.circle.fill")
-                                .foregroundColor(.blue)
+                                .foregroundColor(themeManager.accentColor)
                        }
                    }
                    .contentShape(Rectangle())
--- a/ios/Ascently/Views/AnalyticsView.swift
+++ b/ios/Ascently/Views/AnalyticsView.swift
@@ -2,6 +2,7 @@ import SwiftUI

 struct AnalyticsView: View {
    @EnvironmentObject var dataManager: ClimbingDataManager
+    @EnvironmentObject var themeManager: ThemeManager

    var body: some View {
        NavigationStack {
@@ -25,7 +26,7 @@ struct AnalyticsView: View {
                    if dataManager.isSyncing {
                        HStack(spacing: 2) {
                            ProgressView()
-                                .progressViewStyle(CircularProgressViewStyle(tint: .blue))
+                                .progressViewStyle(CircularProgressViewStyle(tint: themeManager.accentColor))
                                .scaleEffect(0.6)
                        }
                        .padding(.horizontal, 6)
@@ -47,6 +48,7 @@ struct AnalyticsView: View {

 struct OverallStatsSection: View {
    @EnvironmentObject var dataManager: ClimbingDataManager
+    @EnvironmentObject var themeManager: ThemeManager

    var body: some View {
        VStack(alignment: .leading, spacing: 16) {
@@ -59,7 +61,7 @@ struct OverallStatsSection: View {
                    title: "Sessions",
                    value: "\(dataManager.completedSessions().count)",
                    icon: "play.fill",
-                    color: .blue
+                    color: themeManager.accentColor
                )

                StatCard(
@@ -117,13 +119,15 @@ struct StatCard: View {
        .padding()
        .background(
            RoundedRectangle(cornerRadius: 12)
-                .fill(.ultraThinMaterial)
+                .fill(Color(uiColor: .secondarySystemGroupedBackground))
+                .shadow(color: .black.opacity(0.05), radius: 2, x: 0, y: 1)
        )
    }
 }

 struct ProgressChartSection: View {
    @EnvironmentObject var dataManager: ClimbingDataManager
+    @EnvironmentObject var themeManager: ThemeManager
    @State private var selectedSystem: DifficultySystem = .vScale
    @State private var showAllTime: Bool = true
    @State private var cachedGradeCountData: [GradeCount] = []
@@ -178,10 +182,10 @@ struct ProgressChartSection: View {
                            .padding(.vertical, 4)
                            .background(
                                RoundedRectangle(cornerRadius: 6)
-                                    .fill(showAllTime ? .blue : .clear)
-                                    .stroke(.blue.opacity(0.3), lineWidth: 1)
+                                    .fill(showAllTime ? themeManager.accentColor : .clear)
+                                    .stroke(themeManager.accentColor.opacity(0.3), lineWidth: 1)
                            )
-                            .foregroundColor(showAllTime ? .white : .blue)
+                            .foregroundColor(showAllTime ? themeManager.contrastingTextColor : themeManager.accentColor)
                    }

                    Button(action: {
@@ -194,10 +198,10 @@ struct ProgressChartSection: View {
                            .padding(.vertical, 4)
                            .background(
                                RoundedRectangle(cornerRadius: 6)
-                                    .fill(!showAllTime ? .blue : .clear)
-                                    .stroke(.blue.opacity(0.3), lineWidth: 1)
+                                    .fill(!showAllTime ? themeManager.accentColor : .clear)
+                                    .stroke(themeManager.accentColor.opacity(0.3), lineWidth: 1)
                            )
-                            .foregroundColor(!showAllTime ? .white : .blue)
+                            .foregroundColor(!showAllTime ? themeManager.contrastingTextColor : themeManager.accentColor)
                    }
                }

@@ -215,7 +219,7 @@ struct ProgressChartSection: View {
                                    if selectedSystem == system {
                                        Spacer()
                                        Image(systemName: "checkmark")
-                                            .foregroundColor(.blue)
+                                            .foregroundColor(themeManager.accentColor)
                                    }
                                }
                            }
@@ -232,10 +236,10 @@ struct ProgressChartSection: View {
                        .padding(.vertical, 6)
                        .background(
                            RoundedRectangle(cornerRadius: 8)
-                                .fill(.blue.opacity(0.1))
-                                .stroke(.blue.opacity(0.3), lineWidth: 1)
+                                .fill(themeManager.accentColor.opacity(0.1))
+                                .stroke(themeManager.accentColor.opacity(0.3), lineWidth: 1)
                        )
-                        .foregroundColor(.blue)
+                        .foregroundColor(themeManager.accentColor)
                    }
                }
            }
@@ -336,6 +340,7 @@ struct GradeCount {

 struct BarChartView: View {
    let data: [GradeCount]
+    @EnvironmentObject var themeManager: ThemeManager

    private var sortedData: [GradeCount] {
        data.sorted { $0.gradeNumeric < $1.gradeNumeric }
@@ -367,7 +372,7 @@ struct BarChartView: View {
                            VStack(spacing: 4) {
                                // Bar
                                RoundedRectangle(cornerRadius: 4)
-                                    .fill(.blue)
+                                    .fill(themeManager.accentColor)
                                    .frame(
                                        width: barWidth,
                                        height: CGFloat(gradeCount.count) / CGFloat(maxCount)
@@ -377,7 +382,7 @@ struct BarChartView: View {
                                        Text("\(gradeCount.count)")
                                            .font(.caption2)
                                            .fontWeight(.medium)
-                                            .foregroundColor(.white)
+                                            .foregroundColor(themeManager.contrastingTextColor)
                                            .opacity(gradeCount.count > 0 ? 1 : 0)
                                    )

@@ -471,6 +476,7 @@ struct FavoriteGymSection: View {

 struct RecentActivitySection: View {
    @EnvironmentObject var dataManager: ClimbingDataManager
+    @EnvironmentObject var themeManager: ThemeManager

    private var recentSessionsCount: Int {
        dataManager.sessions.count
@@ -485,7 +491,7 @@ struct RecentActivitySection: View {
            HStack {
                Image(systemName: "clock.fill")
                    .font(.title2)
-                    .foregroundColor(.blue)
+                    .foregroundColor(themeManager.accentColor)

                Text("Recent Activity")
                    .font(.title2)
@@ -499,7 +505,7 @@ struct RecentActivitySection: View {
                    HStack {
                        Image(systemName: "play.circle")
                            .font(.subheadline)
-                            .foregroundColor(.blue)
+                            .foregroundColor(themeManager.accentColor)

                        Text("\(recentSessionsCount) sessions")
                            .font(.subheadline)
--- a/ios/Ascently/Views/CalendarView.swift
+++ b/ios/Ascently/Views/CalendarView.swift
@@ -2,6 +2,7 @@ import SwiftUI

 struct CalendarView: View {
    @EnvironmentObject var dataManager: ClimbingDataManager
+    @EnvironmentObject var themeManager: ThemeManager
    let sessions: [ClimbSession]
    @Binding var selectedMonth: Date
    @Binding var selectedDate: Date?
@@ -57,6 +58,7 @@ struct CalendarView: View {
                    let gym = dataManager.gym(withId: activeSession.gymId)
                {
                    ActiveSessionBanner(session: activeSession, gym: gym)
+                        .environmentObject(MusicService.shared)
                        .padding(.horizontal, 16)
                        .padding(.top, 8)
                        .padding(.bottom, 16)
@@ -68,7 +70,7 @@ struct CalendarView: View {
                            Image(systemName: "chevron.left")
                                .font(.title2)
                                .fontWeight(.semibold)
-                                .foregroundColor(.blue)
+                                .foregroundColor(themeManager.accentColor)
                        }
                        .frame(width: 44, height: 44)

@@ -84,7 +86,7 @@ struct CalendarView: View {
                            Image(systemName: "chevron.right")
                                .font(.title2)
                                .fontWeight(.semibold)
-                                .foregroundColor(.blue)
+                                .foregroundColor(themeManager.accentColor)
                        }
                        .frame(width: 44, height: 44)
                    }
@@ -97,10 +99,10 @@ struct CalendarView: View {
                        Text("Today")
                            .font(.subheadline)
                            .fontWeight(.semibold)
-                            .foregroundColor(.white)
+                            .foregroundColor(themeManager.contrastingTextColor)
                            .padding(.horizontal, 20)
                            .padding(.vertical, 8)
-                            .background(Color.blue)
+                            .background(themeManager.accentColor)
                            .clipShape(Capsule())
                    }
                }
@@ -209,6 +211,7 @@ struct CalendarDayCell: View {
    let isToday: Bool
    let isInCurrentMonth: Bool
    let onTap: () -> Void
+    @EnvironmentObject var themeManager: ThemeManager

    var dayNumber: String {
        let formatter = DateFormatter()
@@ -224,9 +227,9 @@ struct CalendarDayCell: View {
                    .fontWeight(sessions.isEmpty ? .regular : .medium)
                    .foregroundColor(
                        isSelected
-                            ? .white
+                            ? themeManager.contrastingTextColor
                            : isToday
-                                ? .blue
+                                ? themeManager.accentColor
                                : !isInCurrentMonth
                                    ? .secondary.opacity(0.3)
                                    : sessions.isEmpty ? .secondary : .primary
@@ -234,7 +237,7 @@ struct CalendarDayCell: View {

                if !sessions.isEmpty {
                    Circle()
-                        .fill(isSelected ? .white : .blue)
+                        .fill(isSelected ? themeManager.contrastingTextColor : themeManager.accentColor)
                        .frame(width: 4, height: 4)
                } else {
                    Spacer()
@@ -247,13 +250,13 @@ struct CalendarDayCell: View {
            .background(
                RoundedRectangle(cornerRadius: 6)
                    .fill(
-                        isSelected ? Color.blue : isToday ? Color.blue.opacity(0.1) : Color.clear
+                        isSelected ? themeManager.accentColor : isToday ? themeManager.accentColor.opacity(0.1) : Color.clear
                    )
            )
            .overlay(
                RoundedRectangle(cornerRadius: 6)
                    .stroke(
-                        isToday && !isSelected ? Color.blue.opacity(0.3) : Color.clear, lineWidth: 1
+                        isToday && !isSelected ? themeManager.accentColor.opacity(0.3) : Color.clear, lineWidth: 1
                    )
            )
        }
--- a/ios/Ascently/Views/Detail/GymDetailView.swift
+++ b/ios/Ascently/Views/Detail/GymDetailView.swift
@@ -3,6 +3,7 @@ import SwiftUI
 struct GymDetailView: View {
    let gymId: UUID
    @EnvironmentObject var dataManager: ClimbingDataManager
+    @EnvironmentObject var themeManager: ThemeManager
    @Environment(\.dismiss) private var dismiss
    @State private var showingDeleteAlert = false

@@ -108,6 +109,7 @@ struct GymDetailView: View {

 struct GymHeaderCard: View {
    let gym: Gym
+    @EnvironmentObject var themeManager: ThemeManager

    var body: some View {
        VStack(alignment: .leading, spacing: 16) {
@@ -145,9 +147,9 @@ struct GymHeaderCard: View {
                                    .padding(.vertical, 6)
                                    .background(
                                        RoundedRectangle(cornerRadius: 12)
-                                            .fill(.blue.opacity(0.1))
+                                            .fill(themeManager.accentColor.opacity(0.1))
                                    )
-                                    .foregroundColor(.blue)
+                                    .foregroundColor(themeManager.accentColor)
                            }
                        }
                        .padding(.horizontal, 1)
@@ -318,8 +320,8 @@ struct ProblemRowCard: View {
        .padding()
        .background(
            RoundedRectangle(cornerRadius: 12)
-                .fill(.ultraThinMaterial)
-                .stroke(.quaternary, lineWidth: 1)
+                .fill(Color(uiColor: .secondarySystemGroupedBackground))
+                .shadow(color: .black.opacity(0.05), radius: 2, x: 0, y: 1)
        )
    }
 }
@@ -371,8 +373,8 @@ struct SessionRowCard: View {
        .padding()
        .background(
            RoundedRectangle(cornerRadius: 12)
-                .fill(.ultraThinMaterial)
-                .stroke(.quaternary, lineWidth: 1)
+                .fill(Color(uiColor: .secondarySystemGroupedBackground))
+                .shadow(color: .black.opacity(0.05), radius: 2, x: 0, y: 1)
        )
    }

--- a/ios/Ascently/Views/Detail/ProblemDetailView.swift
+++ b/ios/Ascently/Views/Detail/ProblemDetailView.swift
@@ -3,6 +3,7 @@ import SwiftUI
 struct ProblemDetailView: View {
    let problemId: UUID
    @EnvironmentObject var dataManager: ClimbingDataManager
+    @EnvironmentObject var themeManager: ThemeManager
    @Environment(\.dismiss) private var dismiss
    @State private var showingDeleteAlert = false
    @State private var showingImageViewer = false
@@ -125,6 +126,7 @@ struct ProblemDetailView: View {
 struct ProblemHeaderCard: View {
    let problem: Problem
    let gym: Gym
+    @EnvironmentObject var themeManager: ThemeManager

    var body: some View {
        VStack(alignment: .leading, spacing: 16) {
@@ -151,7 +153,7 @@ struct ProblemHeaderCard: View {
                    Text(problem.difficulty.grade)
                        .font(.title)
                        .fontWeight(.bold)
-                        .foregroundColor(.blue)
+                        .foregroundColor(themeManager.accentColor)

                    Text(problem.climbType.displayName)
                        .font(.subheadline)
@@ -178,9 +180,9 @@ struct ProblemHeaderCard: View {
                                .padding(.vertical, 4)
                                .background(
                                    RoundedRectangle(cornerRadius: 8)
-                                        .fill(.blue.opacity(0.1))
+                                        .fill(themeManager.accentColor.opacity(0.1))
                                )
-                                .foregroundColor(.blue)
+                                .foregroundColor(themeManager.accentColor)
                        }
                    }
                    .padding(.horizontal, 1)
@@ -223,6 +225,7 @@ struct ProgressSummaryCard: View {
    let totalAttempts: Int
    let successfulAttempts: Int
    let firstSuccess: (date: Date, result: AttemptResult)?
+    @EnvironmentObject var themeManager: ThemeManager

    var body: some View {
        VStack(alignment: .leading, spacing: 16) {
@@ -251,7 +254,7 @@ struct ProgressSummaryCard: View {
                            "\(formatDate(firstSuccess.date)) (\(firstSuccess.result.displayName))"
                        )
                        .font(.subheadline)
-                        .foregroundColor(.blue)
+                        .foregroundColor(themeManager.accentColor)
                    }
                    .padding(.top, 8)
                }
@@ -396,7 +399,8 @@ struct AttemptHistoryCard: View {
        .padding()
        .background(
            RoundedRectangle(cornerRadius: 12)
-                .fill(.ultraThinMaterial)
+                .fill(Color(uiColor: .secondarySystemGroupedBackground))
+                .shadow(color: .black.opacity(0.05), radius: 2, x: 0, y: 1)
        )
    }

--- a/ios/Ascently/Views/Detail/SessionDetailView.swift
+++ b/ios/Ascently/Views/Detail/SessionDetailView.swift
@@ -1,9 +1,12 @@
 import Combine
+import MusicKit
 import SwiftUI

 struct SessionDetailView: View {
    let sessionId: UUID
    @EnvironmentObject var dataManager: ClimbingDataManager
+    @EnvironmentObject var themeManager: ThemeManager
+    @EnvironmentObject var musicService: MusicService
    @Environment(\.dismiss) private var dismiss
    @State private var showingDeleteAlert = false
    @State private var showingAddAttempt = false
@@ -35,26 +38,99 @@ struct SessionDetailView: View {
    }

    var body: some View {
-        ScrollView {
-            LazyVStack(spacing: 20) {
-                if let session = session, let gym = gym {
+        List {
+            if let session = session, let gym = gym {
+                Section {
                    SessionHeaderCard(
                        session: session, gym: gym, stats: sessionStats)
+                    .listRowInsets(EdgeInsets(top: 6, leading: 16, bottom: 6, trailing: 16))
+                    .listRowBackground(Color.clear)
+                    .listRowSeparator(.hidden)
+                    
+                    if session.status == .active && musicService.isMusicEnabled && musicService.isAuthorized {
+                        MusicControlCard()
+                            .listRowInsets(EdgeInsets(top: 6, leading: 16, bottom: 6, trailing: 16))
+                            .listRowBackground(Color.clear)
+                            .listRowSeparator(.hidden)
+                    }

                    SessionStatsCard(stats: sessionStats)
-
-                    AttemptsSection(
-                        attemptsWithProblems: attemptsWithProblems,
-                        attemptToDelete: $attemptToDelete,
-                        editingAttempt: $editingAttempt)
-                } else {
-                    Text("Session not found")
-                        .foregroundColor(.secondary)
+                    .listRowInsets(EdgeInsets(top: 6, leading: 16, bottom: 6, trailing: 16))
+                    .listRowBackground(Color.clear)
+                    .listRowSeparator(.hidden)
                }
-            }
-            .padding()
-        }

+                Section {
+                    if attemptsWithProblems.isEmpty {
+                        VStack(spacing: 12) {
+                            Image(systemName: "hand.raised.slash")
+                                .font(.title)
+                                .foregroundColor(.secondary)
+
+                            Text("No attempts yet")
+                                .font(.headline)
+                                .foregroundColor(.secondary)
+
+                            Text("Start attempting problems to see your progress!")
+                                .font(.subheadline)
+                                .foregroundColor(.secondary)
+                                .multilineTextAlignment(.center)
+                        }
+                        .frame(maxWidth: .infinity)
+                        .padding()
+                        .background(
+                            RoundedRectangle(cornerRadius: 16)
+                                .fill(.regularMaterial)
+                        )
+                        .listRowBackground(Color.clear)
+                        .listRowSeparator(.hidden)
+                        .listRowInsets(EdgeInsets(top: 6, leading: 16, bottom: 6, trailing: 16))
+                    } else {
+                        ForEach(attemptsWithProblems.indices, id: \.self) { index in
+                            let (attempt, problem) = attemptsWithProblems[index]
+                            AttemptCard(attempt: attempt, problem: problem)
+                                .listRowBackground(Color.clear)
+                                .listRowSeparator(.hidden)
+                                .listRowInsets(EdgeInsets(top: 6, leading: 16, bottom: 6, trailing: 16))
+                                .swipeActions(edge: .trailing, allowsFullSwipe: true) {
+                                    Button(role: .destructive) {
+                                        let impactFeedback = UIImpactFeedbackGenerator(style: .medium)
+                                        impactFeedback.impactOccurred()
+                                        attemptToDelete = attempt
+                                    } label: {
+                                        Label("Delete", systemImage: "trash")
+                                    }
+                                    .tint(.red)
+                                    .accessibilityLabel("Delete attempt")
+
+                                    Button {
+                                        editingAttempt = attempt
+                                    } label: {
+                                        Label("Edit", systemImage: "pencil")
+                                    }
+                                    .tint(.indigo)
+                                    .accessibilityLabel("Edit attempt")
+                                }
+                                .onTapGesture {
+                                    editingAttempt = attempt
+                                }
+                        }
+                    }
+                } header: {
+                    Text("Attempts (\(attemptsWithProblems.count))")
+                        .font(.title2)
+                        .fontWeight(.bold)
+                        .foregroundColor(.primary)
+                        .textCase(nil)
+                        .padding(.bottom, 8)
+                        .padding(.top, 16)
+                }
+            } else {
+                Text("Session not found")
+                    .foregroundColor(.secondary)
+            }
+        }
+        .listStyle(.plain)
        .navigationTitle("Session Details")
        .navigationBarTitleDisplayMode(.inline)
        .toolbar {
@@ -112,9 +188,9 @@ struct SessionDetailView: View {
                Button(action: { showingAddAttempt = true }) {
                    Image(systemName: "plus")
                        .font(.title2)
-                        .foregroundColor(.white)
+                        .foregroundColor(.white) // Keep white for contrast on colored button
                        .frame(width: 56, height: 56)
-                        .background(Circle().fill(.blue))
+                        .background(Circle().fill(themeManager.accentColor))
                        .shadow(radius: 4)
                }
                .padding()
@@ -162,6 +238,7 @@ struct SessionHeaderCard: View {
    let session: ClimbSession
    let gym: Gym
    let stats: SessionStats
+    @EnvironmentObject var themeManager: ThemeManager

    var body: some View {
        VStack(alignment: .leading, spacing: 16) {
@@ -172,7 +249,7 @@ struct SessionHeaderCard: View {

                Text(formatDate(session.date))
                    .font(.title2)
-                    .foregroundColor(.blue)
+                    .foregroundColor(themeManager.accentColor)

                if session.status == .active {
                    if let startTime = session.startTime {
@@ -200,12 +277,12 @@ struct SessionHeaderCard: View {
            // Status indicator
            HStack {
                Image(systemName: session.status == .active ? "play.fill" : "checkmark.circle.fill")
-                    .foregroundColor(session.status == .active ? .green : .blue)
+                    .foregroundColor(session.status == .active ? .green : themeManager.accentColor)

                Text(session.status == .active ? "In Progress" : "Completed")
                    .font(.subheadline)
                    .fontWeight(.medium)
-                    .foregroundColor(session.status == .active ? .green : .blue)
+                    .foregroundColor(session.status == .active ? .green : themeManager.accentColor)

                Spacer()
            }
@@ -213,7 +290,7 @@ struct SessionHeaderCard: View {
            .padding(.vertical, 6)
            .background(
                RoundedRectangle(cornerRadius: 8)
-                    .fill((session.status == .active ? Color.green : Color.blue).opacity(0.1))
+                    .fill((session.status == .active ? Color.green : themeManager.accentColor).opacity(0.1))
            )
        }
        .padding()
@@ -264,13 +341,14 @@ struct SessionStatsCard: View {
 struct StatItem: View {
    let label: String
    let value: String
+    @EnvironmentObject var themeManager: ThemeManager

    var body: some View {
        VStack(spacing: 4) {
            Text(value)
                .font(.title2)
                .fontWeight(.bold)
-                .foregroundColor(.blue)
+                .foregroundColor(themeManager.accentColor)

            Text(label)
                .font(.caption)
@@ -280,85 +358,12 @@ struct StatItem: View {
    }
 }

-struct AttemptsSection: View {
-    let attemptsWithProblems: [(Attempt, Problem)]
-    @Binding var attemptToDelete: Attempt?
-    @Binding var editingAttempt: Attempt?
-    @EnvironmentObject var dataManager: ClimbingDataManager
-
-    var body: some View {
-        VStack(alignment: .leading, spacing: 16) {
-            Text("Attempts (\(attemptsWithProblems.count))")
-                .font(.title2)
-                .fontWeight(.bold)
-
-            if attemptsWithProblems.isEmpty {
-                VStack(spacing: 12) {
-                    Image(systemName: "hand.raised.slash")
-                        .font(.title)
-                        .foregroundColor(.secondary)
-
-                    Text("No attempts yet")
-                        .font(.headline)
-                        .foregroundColor(.secondary)
-
-                    Text("Start attempting problems to see your progress!")
-                        .font(.subheadline)
-                        .foregroundColor(.secondary)
-                        .multilineTextAlignment(.center)
-                }
-                .frame(maxWidth: .infinity)
-                .padding()
-                .background(
-                    RoundedRectangle(cornerRadius: 16)
-                        .fill(.regularMaterial)
-                )
-            } else {
-                List {
-                    ForEach(attemptsWithProblems.indices, id: \.self) { index in
-                        let (attempt, problem) = attemptsWithProblems[index]
-                        AttemptCard(attempt: attempt, problem: problem)
-                            .listRowBackground(Color.clear)
-                            .listRowSeparator(.hidden)
-                            .listRowInsets(EdgeInsets(top: 6, leading: 0, bottom: 6, trailing: 0))
-                            .swipeActions(edge: .trailing, allowsFullSwipe: true) {
-                                Button(role: .destructive) {
-                                    // Add haptic feedback for delete action
-                                    let impactFeedback = UIImpactFeedbackGenerator(style: .medium)
-                                    impactFeedback.impactOccurred()
-                                    attemptToDelete = attempt
-                                } label: {
-                                    Label("Delete", systemImage: "trash")
-                                }
-                                .accessibilityLabel("Delete attempt")
-                                .accessibilityHint("Removes this attempt from the session")
-
-                                Button {
-                                    editingAttempt = attempt
-                                } label: {
-                                    Label("Edit", systemImage: "pencil")
-                                }
-                                .tint(.blue)
-                                .accessibilityLabel("Edit attempt")
-                                .accessibilityHint("Modify the details of this attempt")
-                            }
-                            .onTapGesture {
-                                editingAttempt = attempt
-                            }
-                    }
-                }
-                .listStyle(.plain)
-                .scrollDisabled(true)
-                .frame(height: CGFloat(attemptsWithProblems.count) * 120)
-            }
-        }
-
-    }
-}
+// AttemptsSection removed as it is now integrated into the main List

 struct AttemptCard: View {
    let attempt: Attempt
    let problem: Problem
+    @EnvironmentObject var themeManager: ThemeManager

    var body: some View {
        VStack(alignment: .leading, spacing: 12) {
@@ -370,7 +375,7 @@ struct AttemptCard: View {

                    Text("\(problem.difficulty.system.displayName): \(problem.difficulty.grade)")
                        .font(.subheadline)
-                        .foregroundColor(.blue)
+                        .foregroundColor(themeManager.accentColor)

                    if let location = problem.location {
                        Text(location)
@@ -399,9 +404,11 @@ struct AttemptCard: View {
            }
        }
        .padding()
-        .background(.regularMaterial)
-        .cornerRadius(12)
-        .shadow(radius: 2)
+        .background(
+            RoundedRectangle(cornerRadius: 12)
+                .fill(Color(uiColor: .secondarySystemGroupedBackground)) // Better contrast in light mode
+                .shadow(color: .black.opacity(0.05), radius: 2, x: 0, y: 1)
+        )
    }
 }

@@ -444,6 +451,53 @@ struct SessionStats {
    let uniqueProblemsCompleted: Int
 }

+struct MusicControlCard: View {
+    @EnvironmentObject var musicService: MusicService
+    
+    var body: some View {
+        HStack {
+            Image(systemName: "music.note")
+                .font(.title2)
+                .foregroundColor(.pink)
+                .frame(width: 40, height: 40)
+                .background(Color.pink.opacity(0.1))
+                .clipShape(Circle())
+            
+            VStack(alignment: .leading, spacing: 2) {
+                Text("Music")
+                    .font(.headline)
+                
+                if let playlistId = musicService.selectedPlaylistId,
+                   let playlist = musicService.playlists.first(where: { $0.id.rawValue == playlistId }) {
+                    Text(playlist.name)
+                        .font(.caption)
+                        .foregroundColor(.secondary)
+                } else {
+                    Text("No playlist selected")
+                        .font(.caption)
+                        .foregroundColor(.secondary)
+                }
+            }
+            
+            Spacer()
+            
+            Button(action: {
+                musicService.togglePlayback()
+            }) {
+                Image(systemName: musicService.isPlaying ? "pause.circle.fill" : "play.circle.fill")
+                    .font(.system(size: 32))
+                    .foregroundColor(.pink)
+            }
+        }
+        .padding()
+        .background(
+            RoundedRectangle(cornerRadius: 16)
+                .fill(Color(.secondarySystemGroupedBackground))
+                .shadow(color: .black.opacity(0.05), radius: 5, x: 0, y: 2)
+        )
+    }
+}
+
 #Preview {
    NavigationView {
        SessionDetailView(sessionId: UUID())
--- a/ios/Ascently/Views/GymsView.swift
+++ b/ios/Ascently/Views/GymsView.swift
@@ -2,6 +2,7 @@ import SwiftUI

 struct GymsView: View {
    @EnvironmentObject var dataManager: ClimbingDataManager
+    @EnvironmentObject var themeManager: ThemeManager
    @State private var showingAddGym = false

    var body: some View {
@@ -19,7 +20,7 @@ struct GymsView: View {
                    if dataManager.isSyncing {
                        HStack(spacing: 2) {
                            ProgressView()
-                                .progressViewStyle(CircularProgressViewStyle(tint: .blue))
+                                .progressViewStyle(CircularProgressViewStyle(tint: themeManager.accentColor))
                                .scaleEffect(0.6)
                        }
                        .padding(.horizontal, 6)
@@ -48,6 +49,7 @@ struct GymsView: View {

 struct GymsList: View {
    @EnvironmentObject var dataManager: ClimbingDataManager
+    @EnvironmentObject var themeManager: ThemeManager
    @State private var gymToDelete: Gym?
    @State private var gymToEdit: Gym?

@@ -62,6 +64,7 @@ struct GymsList: View {
                } label: {
                    Label("Delete", systemImage: "trash")
                }
+                .tint(.red)

                Button {
                    gymToEdit = gym
@@ -71,7 +74,7 @@ struct GymsList: View {
                        Text("Edit")
                    }
                }
-                .tint(.blue)
+                .tint(.indigo)
            }
        }
        .alert("Delete Gym", isPresented: .constant(gymToDelete != nil)) {
@@ -98,6 +101,7 @@ struct GymsList: View {
 struct GymRow: View {
    let gym: Gym
    @EnvironmentObject var dataManager: ClimbingDataManager
+    @EnvironmentObject var themeManager: ThemeManager

    private var problemCount: Int {
        dataManager.problems(forGym: gym.id).count
@@ -133,9 +137,9 @@ struct GymRow: View {
                                .padding(.vertical, 4)
                                .background(
                                    RoundedRectangle(cornerRadius: 8)
-                                        .fill(.blue.opacity(0.1))
+                                        .fill(themeManager.accentColor.opacity(0.1))
                                )
-                                .foregroundColor(.blue)
+                                .foregroundColor(themeManager.accentColor)
                        }
                    }
                }
--- a/ios/Ascently/Views/ProblemsView.swift
+++ b/ios/Ascently/Views/ProblemsView.swift
@@ -2,15 +2,22 @@ import SwiftUI

 struct ProblemsView: View {
    @EnvironmentObject var dataManager: ClimbingDataManager
+    @EnvironmentObject var themeManager: ThemeManager
    @State private var showingAddProblem = false
    @State private var selectedClimbType: ClimbType?
    @State private var selectedGym: Gym?
    @State private var searchText = ""
    @State private var showingSearch = false
+    @State private var showingFilters = false
    @FocusState private var isSearchFocused: Bool

    @State private var cachedFilteredProblems: [Problem] = []

+    // State moved from ProblemsList
+    @State private var problemToDelete: Problem?
+    @State private var problemToEdit: Problem?
+    @State private var animationKey = 0
+
    private func updateFilteredProblems() {
        Task(priority: .userInitiated) {
            let result = await computeFilteredProblems()
@@ -70,61 +77,68 @@ struct ProblemsView: View {
    var body: some View {
        NavigationStack {
            Group {
-                VStack(spacing: 0) {
-                    if showingSearch {
-                        HStack(spacing: 8) {
-                            Image(systemName: "magnifyingglass")
-                                .foregroundColor(.secondary)
-                                .font(.system(size: 16, weight: .medium))
-
-                            TextField("Search problems...", text: $searchText)
-                                .textFieldStyle(.plain)
-                                .font(.system(size: 16))
-                                .focused($isSearchFocused)
-                                .submitLabel(.search)
-                        }
-                        .padding(.horizontal, 12)
-                        .padding(.vertical, 10)
-                        .background {
-                            if #available(iOS 18.0, *) {
-                                RoundedRectangle(cornerRadius: 12)
-                                    .fill(.regularMaterial)
-                                    .overlay {
-                                        RoundedRectangle(cornerRadius: 12)
-                                            .stroke(.quaternary, lineWidth: 0.5)
-                                    }
-                            } else {
-                                RoundedRectangle(cornerRadius: 10)
-                                    .fill(Color(.systemGray6))
-                                    .overlay {
-                                        RoundedRectangle(cornerRadius: 10)
-                                            .stroke(Color(.systemGray4), lineWidth: 0.5)
-                                    }
-                            }
-                        }
-                        .padding(.horizontal)
-                        .padding(.top, 8)
-                        .animation(.easeInOut(duration: 0.3), value: showingSearch)
-                    }
-
-                    if !dataManager.problems.isEmpty && !showingSearch {
-                        FilterSection(
-                            selectedClimbType: $selectedClimbType,
-                            selectedGym: $selectedGym,
-                            filteredProblems: cachedFilteredProblems
-                        )
-                        .padding()
-                        .background(.regularMaterial)
-                    }
-
-                    if cachedFilteredProblems.isEmpty {
+                if cachedFilteredProblems.isEmpty {
+                    VStack(spacing: 0) {
+                        headerContent
+                        
                        EmptyProblemsView(
                            isEmpty: dataManager.problems.isEmpty,
                            isFiltered: !dataManager.problems.isEmpty
                        )
-                    } else {
-                        ProblemsList(problems: cachedFilteredProblems)
                    }
+                } else {
+                    List {
+                        if showingSearch {
+                            Section {
+                                headerContent
+                            }
+                            .listRowInsets(EdgeInsets())
+                            .listRowSeparator(.hidden)
+                            .listRowBackground(Color.clear)
+                        }
+
+                        ForEach(cachedFilteredProblems) { problem in
+                            NavigationLink(destination: ProblemDetailView(problemId: problem.id)) {
+                                ProblemRow(problem: problem)
+                            }
+                            .swipeActions(edge: .trailing, allowsFullSwipe: false) {
+                                Button(role: .destructive) {
+                                    problemToDelete = problem
+                                } label: {
+                                    Label("Delete", systemImage: "trash")
+                                }
+                                .tint(.red)
+
+                                Button {
+                                    withAnimation(.spring(response: 0.5, dampingFraction: 0.8, blendDuration: 0.1))
+                                    {
+                                        let updatedProblem = problem.updated(isActive: !problem.isActive)
+                                        dataManager.updateProblem(updatedProblem)
+                                    }
+                                } label: {
+                                    Label(
+                                        problem.isActive ? "Mark as Reset" : "Mark as Active",
+                                        systemImage: problem.isActive ? "xmark.circle" : "checkmark.circle")
+                                }
+                                .tint(.orange)
+
+                                Button {
+                                    problemToEdit = problem
+                                } label: {
+                                    HStack {
+                                        Image(systemName: "pencil")
+                                        Text("Edit")
+                                    }
+                                }
+                                .tint(.indigo)
+                            }
+                        }
+                    }
+                    .listStyle(.plain)
+                    .animation(
+                        .spring(response: 0.5, dampingFraction: 0.8, blendDuration: 0.1),
+                        value: animationKey
+                    )
                }
            }
            .navigationTitle("Problems")
@@ -134,7 +148,7 @@ struct ProblemsView: View {
                    if dataManager.isSyncing {
                        HStack(spacing: 2) {
                            ProgressView()
-                                .progressViewStyle(CircularProgressViewStyle(tint: .blue))
+                                .progressViewStyle(CircularProgressViewStyle(tint: themeManager.accentColor))
                                .scaleEffect(0.6)
                        }
                        .padding(.horizontal, 6)
@@ -162,7 +176,15 @@ struct ProblemsView: View {
                    }) {
                        Image(systemName: showingSearch ? "xmark.circle.fill" : "magnifyingglass")
                            .font(.system(size: 16, weight: .medium))
-                            .foregroundColor(showingSearch ? .secondary : .blue)
+                            .foregroundColor(showingSearch ? .secondary : themeManager.accentColor)
+                    }
+
+                    Button(action: {
+                        showingFilters = true
+                    }) {
+                        Image(systemName: (selectedClimbType != nil || selectedGym != nil) ? "line.3.horizontal.decrease.circle.fill" : "line.3.horizontal.decrease.circle")
+                            .font(.system(size: 16, weight: .medium))
+                            .foregroundColor(themeManager.accentColor)
                    }

                    if !dataManager.gyms.isEmpty {
@@ -175,6 +197,32 @@ struct ProblemsView: View {
            .sheet(isPresented: $showingAddProblem) {
                AddEditProblemView()
            }
+            .sheet(isPresented: $showingFilters) {
+                FilterSheet(
+                    selectedClimbType: $selectedClimbType,
+                    selectedGym: $selectedGym,
+                    filteredProblems: cachedFilteredProblems
+                )
+                .presentationDetents([.height(320)])
+            }
+            .sheet(item: $problemToEdit) { problem in
+                AddEditProblemView(problemId: problem.id)
+            }
+            .alert("Delete Problem", isPresented: .constant(problemToDelete != nil)) {
+                Button("Cancel", role: .cancel) {
+                    problemToDelete = nil
+                }
+                Button("Delete", role: .destructive) {
+                    if let problem = problemToDelete {
+                        dataManager.deleteProblem(problem)
+                        problemToDelete = nil
+                    }
+                }
+            } message: {
+                Text(
+                    "Are you sure you want to delete this problem? This will also delete all associated attempts."
+                )
+            }
        }
        .onAppear {
            updateFilteredProblems()
@@ -191,11 +239,57 @@ struct ProblemsView: View {
        .onChange(of: selectedGym) {
            updateFilteredProblems()
        }
+        .onChange(of: cachedFilteredProblems) {
+            animationKey += 1
+        }
+    }
+
+    @ViewBuilder
+    private var headerContent: some View {
+        VStack(spacing: 0) {
+            if showingSearch {
+                HStack(spacing: 8) {
+                    Image(systemName: "magnifyingglass")
+                        .foregroundColor(.secondary)
+                        .font(.system(size: 16, weight: .medium))
+
+                    TextField("Search problems...", text: $searchText)
+                        .textFieldStyle(.plain)
+                        .font(.system(size: 16))
+                        .focused($isSearchFocused)
+                        .submitLabel(.search)
+                }
+                .padding(.horizontal, 12)
+                .padding(.vertical, 10)
+                .background {
+                    if #available(iOS 18.0, *) {
+                        RoundedRectangle(cornerRadius: 12)
+                            .fill(.regularMaterial)
+                            .overlay {
+                                RoundedRectangle(cornerRadius: 12)
+                                    .stroke(.quaternary, lineWidth: 0.5)
+                            }
+                    } else {
+                        RoundedRectangle(cornerRadius: 10)
+                            .fill(Color(.systemGray6))
+                            .overlay {
+                                RoundedRectangle(cornerRadius: 10)
+                                    .stroke(Color(.systemGray4), lineWidth: 0.5)
+                            }
+                    }
+                }
+                .padding(.horizontal)
+                .padding(.top, 8)
+                .padding(.bottom, 8)
+                .animation(.easeInOut(duration: 0.3), value: showingSearch)
+            }
+        }
    }
 }

 struct FilterSection: View {
    @EnvironmentObject var dataManager: ClimbingDataManager
+    @EnvironmentObject var themeManager: ThemeManager
    @Binding var selectedClimbType: ClimbType?
    @Binding var selectedGym: Gym?
    let filteredProblems: [Problem]
@@ -278,6 +372,7 @@ struct FilterChip: View {
    let title: String
    let isSelected: Bool
    let action: () -> Void
+    @EnvironmentObject var themeManager: ThemeManager

    var body: some View {
        Button(action: action) {
@@ -288,93 +383,21 @@ struct FilterChip: View {
                .padding(.vertical, 6)
                .background(
                    RoundedRectangle(cornerRadius: 16)
-                        .fill(isSelected ? .blue : .clear)
-                        .stroke(.blue, lineWidth: 1)
+                        .fill(isSelected ? themeManager.accentColor : .clear)
+                        .stroke(themeManager.accentColor, lineWidth: 1)
                )
-                .foregroundColor(isSelected ? .white : .blue)
+                .foregroundColor(isSelected ? themeManager.contrastingTextColor : themeManager.accentColor)
        }
        .buttonStyle(.plain)
    }
 }

-struct ProblemsList: View {
-    let problems: [Problem]
-    @EnvironmentObject var dataManager: ClimbingDataManager
-    @State private var problemToDelete: Problem?
-    @State private var problemToEdit: Problem?
-    @State private var animationKey = 0

-    var body: some View {
-        List(problems, id: \.id) { problem in
-            NavigationLink(destination: ProblemDetailView(problemId: problem.id)) {
-                ProblemRow(problem: problem)
-            }
-            .swipeActions(edge: .trailing, allowsFullSwipe: false) {
-                Button(role: .destructive) {
-                    problemToDelete = problem
-                } label: {
-                    Label("Delete", systemImage: "trash")
-                }
-
-                Button {
-                    withAnimation(.spring(response: 0.5, dampingFraction: 0.8, blendDuration: 0.1))
-                    {
-                        let updatedProblem = problem.updated(isActive: !problem.isActive)
-                        dataManager.updateProblem(updatedProblem)
-                    }
-                } label: {
-                    Label(
-                        problem.isActive ? "Mark as Reset" : "Mark as Active",
-                        systemImage: problem.isActive ? "xmark.circle" : "checkmark.circle")
-                }
-                .tint(.orange)
-
-                Button {
-                    problemToEdit = problem
-                } label: {
-                    HStack {
-                        Image(systemName: "pencil")
-                        Text("Edit")
-                    }
-                }
-                .tint(.blue)
-            }
-        }
-        .animation(
-            .spring(response: 0.5, dampingFraction: 0.8, blendDuration: 0.1),
-            value: animationKey
-        )
-        .onChange(of: problems) {
-            animationKey += 1
-        }
-        .listStyle(.plain)
-        .scrollContentBackground(.hidden)
-        .scrollIndicators(.hidden)
-        .clipped()
-        .alert("Delete Problem", isPresented: .constant(problemToDelete != nil)) {
-            Button("Cancel", role: .cancel) {
-                problemToDelete = nil
-            }
-            Button("Delete", role: .destructive) {
-                if let problem = problemToDelete {
-                    dataManager.deleteProblem(problem)
-                    problemToDelete = nil
-                }
-            }
-        } message: {
-            Text(
-                "Are you sure you want to delete this problem? This will also delete all associated attempts."
-            )
-        }
-        .sheet(item: $problemToEdit) { problem in
-            AddEditProblemView(problemId: problem.id)
-        }
-    }
-}

 struct ProblemRow: View {
    let problem: Problem
    @EnvironmentObject var dataManager: ClimbingDataManager
+    @EnvironmentObject var themeManager: ThemeManager

    private var gym: Gym? {
        dataManager.gym(withId: problem.gymId)
@@ -407,7 +430,7 @@ struct ProblemRow: View {
                        if !problem.imagePaths.isEmpty {
                            Image(systemName: "photo")
                                .font(.system(size: 14, weight: .medium))
-                                .foregroundColor(.blue)
+                                .foregroundColor(themeManager.accentColor)
                        }

                        if isCompleted {
@@ -419,7 +442,7 @@ struct ProblemRow: View {
                        Text(problem.difficulty.grade)
                            .font(.title2)
                            .fontWeight(.bold)
-                            .foregroundColor(.blue)
+                            .foregroundColor(themeManager.accentColor)
                    }

                    Text(problem.climbType.displayName)
@@ -444,9 +467,9 @@ struct ProblemRow: View {
                                .padding(.vertical, 2)
                                .background(
                                    RoundedRectangle(cornerRadius: 4)
-                                        .fill(.blue.opacity(0.1))
+                                        .fill(themeManager.accentColor.opacity(0.1))
                                )
-                                .foregroundColor(.blue)
+                                .foregroundColor(themeManager.accentColor)
                        }
                    }
                }
@@ -523,6 +546,71 @@ struct EmptyProblemsView: View {
    }
 }

+struct FilterSheet: View {
+    @Binding var selectedClimbType: ClimbType?
+    @Binding var selectedGym: Gym?
+    let filteredProblems: [Problem]
+    @Environment(\.dismiss) var dismiss
+    @EnvironmentObject var themeManager: ThemeManager
+    
+    var body: some View {
+        NavigationStack {
+            ScrollView {
+                FilterSection(
+                    selectedClimbType: $selectedClimbType,
+                    selectedGym: $selectedGym,
+                    filteredProblems: filteredProblems
+                )
+                .padding()
+            }
+            .navigationTitle("Filters")
+            .navigationBarTitleDisplayMode(.inline)
+            .toolbar {
+                ToolbarItem(placement: .navigationBarTrailing) {
+                    Button(action: {
+                        dismiss()
+                    }) {
+                        Text("Done")
+                            .font(.subheadline)
+                            .fontWeight(.semibold)
+                            .padding(.horizontal, 16)
+                            .padding(.vertical, 6)
+                            .background(.ultraThinMaterial)
+                            .clipShape(Capsule())
+                            .overlay(
+                                Capsule()
+                                    .stroke(Color.secondary.opacity(0.2), lineWidth: 0.5)
+                            )
+                            .foregroundColor(themeManager.accentColor)
+                    }
+                }
+                
+                ToolbarItem(placement: .navigationBarLeading) {
+                    if selectedClimbType != nil || selectedGym != nil {
+                        Button(action: {
+                            selectedClimbType = nil
+                            selectedGym = nil
+                        }) {
+                            Text("Reset")
+                                .font(.subheadline)
+                                .fontWeight(.medium)
+                                .padding(.horizontal, 16)
+                                .padding(.vertical, 6)
+                                .background(.ultraThinMaterial)
+                                .clipShape(Capsule())
+                                .overlay(
+                                    Capsule()
+                                        .stroke(Color.secondary.opacity(0.2), lineWidth: 0.5)
+                                )
+                                .foregroundColor(.red)
+                        }
+                    }
+                }
+            }
+        }
+    }
+}
+
 #Preview {
    ProblemsView()
        .environmentObject(ClimbingDataManager.preview)
--- a/ios/Ascently/Views/SessionsView.swift
+++ b/ios/Ascently/Views/SessionsView.swift
@@ -122,6 +122,7 @@ struct SessionsList: View {
            {
                Section {
                    ActiveSessionBanner(session: activeSession, gym: gym)
+                        .environmentObject(MusicService.shared)
                        .padding(.horizontal, 16)
                        .listRowInsets(EdgeInsets(top: 16, leading: 0, bottom: 24, trailing: 0))
                        .listRowBackground(Color.clear)
@@ -142,6 +143,7 @@ struct SessionsList: View {
                            } label: {
                                Label("Delete", systemImage: "trash")
                            }
+                            .tint(.red)
                        }
                    }
                } header: {
@@ -177,6 +179,17 @@ struct ActiveSessionBanner: View {
    let gym: Gym
    @EnvironmentObject var dataManager: ClimbingDataManager
    @State private var navigateToDetail = false
+    
+    // Access MusicService via DataManager if possible, or EnvironmentObject if injected
+    // Since DataManager holds MusicService, we can access it through there if we expose it or inject it.
+    // In SettingsView we saw .environmentObject(dataManager.musicService).
+    // We should probably inject it here too or access via dataManager if it's public.
+    // Let's check ClimbingDataManager again. It has `let musicService = MusicService.shared`.
+    // But it's not @Published so it won't trigger updates unless we observe the service itself.
+    // The best way is to use @EnvironmentObject var musicService: MusicService
+    // and ensure it's injected in the parent view.
+    
+    @EnvironmentObject var musicService: MusicService

    var body: some View {
        HStack {
@@ -200,6 +213,19 @@ struct ActiveSessionBanner: View {
                        .foregroundColor(.secondary)
                        .monospacedDigit()
                }
+                
+                if musicService.isMusicEnabled && musicService.isAuthorized {
+                    Button(action: {
+                        musicService.togglePlayback()
+                    }) {
+                        HStack(spacing: 4) {
+                            Image(systemName: musicService.isPlaying ? "pause.fill" : "play.fill")
+                                .font(.caption)
+                        }
+                        .foregroundColor(.pink)
+                        .padding(.top, 2)
+                    }
+                }
            }
            .frame(maxWidth: .infinity, alignment: .leading)
            .contentShape(Rectangle())
--- a/ios/Ascently/Views/SettingsView.swift
+++ b/ios/Ascently/Views/SettingsView.swift
@@ -1,4 +1,5 @@
 import HealthKit
+import MusicKit
 import SwiftUI
 import UniformTypeIdentifiers

@@ -9,6 +10,7 @@ enum SheetType {

 struct SettingsView: View {
    @EnvironmentObject var dataManager: ClimbingDataManager
+    @EnvironmentObject var themeManager: ThemeManager
    @State private var activeSheet: SheetType?

    var body: some View {
@@ -20,6 +22,11 @@ struct SettingsView: View {
                HealthKitSection()
                    .environmentObject(dataManager.healthKitService)

+                MusicSection()
+                    .environmentObject(dataManager.musicService)
+
+                AppearanceSection()
+
                DataManagementSection(
                    activeSheet: $activeSheet
                )
@@ -75,8 +82,90 @@ extension SheetType: Identifiable {
    }
 }

+struct AppearanceSection: View {
+    @EnvironmentObject var themeManager: ThemeManager
+    
+    let columns = [
+        GridItem(.adaptive(minimum: 44))
+    ]
+    
+    var body: some View {
+        Section("Appearance") {
+            VStack(alignment: .leading, spacing: 12) {
+                Text("Accent Color")
+                    .font(.caption)
+                    .foregroundColor(.secondary)
+                    .textCase(.uppercase)
+                
+                LazyVGrid(columns: columns, spacing: 12) {
+                    ForEach(ThemeManager.presetColors, id: \.self) { color in
+                        Circle()
+                            .fill(color)
+                            .frame(width: 44, height: 44)
+                            .overlay(
+                                ZStack {
+                                    if isSelected(color) {
+                                        Image(systemName: "checkmark")
+                                            .font(.headline)
+                                            .foregroundColor(.white)
+                                            .shadow(radius: 1)
+                                    }
+                                }
+                            )
+                            .onTapGesture {
+                                withAnimation {
+                                    themeManager.accentColor = color
+                                }
+                            }
+                            .accessibilityLabel(colorDescription(for: color))
+                            .accessibilityAddTraits(isSelected(color) ? .isSelected : [])
+                    }
+                }
+                .padding(.vertical, 8)
+            }
+            
+            if !isSelected(.blue) {
+                Button("Reset to Default") {
+                    withAnimation {
+                        themeManager.resetToDefault()
+                    }
+                }
+                .foregroundColor(.red)
+            }
+        }
+    }
+    
+    private func isSelected(_ color: Color) -> Bool {
+        // Compare using UIColor to handle different Color initializers
+        let selectedUIColor = UIColor(themeManager.accentColor)
+        let targetUIColor = UIColor(color)
+        
+        // Simple equality check might fail for some system colors, so we check components if needed
+        // But usually UIColor equality is robust enough for system colors
+        return selectedUIColor == targetUIColor
+    }
+    
+    private func colorDescription(for color: Color) -> String {
+        switch color {
+        case .blue: return "Blue"
+        case .purple: return "Purple"
+        case .pink: return "Pink"
+        case .red: return "Red"
+        case .orange: return "Orange"
+        case .green: return "Green"
+        case .teal: return "Teal"
+        case .indigo: return "Indigo"
+        case .mint: return "Mint"
+        case Color(uiColor: .systemBrown): return "Brown"
+        case Color(uiColor: .systemCyan): return "Cyan"
+        default: return "Color"
+        }
+    }
+}
+
 struct DataManagementSection: View {
    @EnvironmentObject var dataManager: ClimbingDataManager
+    @EnvironmentObject var themeManager: ThemeManager
    @Binding var activeSheet: SheetType?
    @State private var showingResetAlert = false
    @State private var isExporting = false
@@ -100,7 +189,7 @@ struct DataManagementSection: View {
                            .foregroundColor(.secondary)
                    } else {
                        Image(systemName: "square.and.arrow.up")
-                            .foregroundColor(.blue)
+                            .foregroundColor(themeManager.accentColor)
                        Text("Export Data")
                    }
                    Spacer()
@@ -253,6 +342,7 @@ struct DataManagementSection: View {
 }

 struct AppInfoSection: View {
+    @EnvironmentObject var themeManager: ThemeManager
    private var appVersion: String {
        Bundle.main.infoDictionary?["CFBundleShortVersionString"] as? String ?? "Unknown"
    }
@@ -265,7 +355,7 @@ struct AppInfoSection: View {
        Section("App Information") {
            HStack {
                Image(systemName: "info.circle")
-                    .foregroundColor(.blue)
+                    .foregroundColor(themeManager.accentColor)
                Text("Version")
                Spacer()
                Text("\(appVersion) (\(buildNumber))")
@@ -278,6 +368,7 @@ struct AppInfoSection: View {
 struct ExportDataView: View {
    let data: Data
    @Environment(\.dismiss) private var dismiss
+    @EnvironmentObject var themeManager: ThemeManager
    @State private var tempFileURL: URL?
    @State private var isCreatingFile = true

@@ -291,7 +382,7 @@ struct ExportDataView: View {
                    VStack(spacing: 20) {
                        ProgressView()
                            .scaleEffect(1.5)
-                            .tint(.blue)
+                            .tint(themeManager.accentColor)

                        Text("Preparing Your Export")
                            .font(.title2)
@@ -330,12 +421,12 @@ struct ExportDataView: View {
                            ) {
                                Label("Share Data", systemImage: "square.and.arrow.up")
                                    .font(.headline)
-                                    .foregroundColor(.white)
+                                    .foregroundColor(themeManager.contrastingTextColor)
                                    .frame(maxWidth: .infinity)
                                    .padding()
                                    .background(
                                        RoundedRectangle(cornerRadius: 12)
-                                            .fill(.blue)
+                                            .fill(themeManager.accentColor)
                                    )
                            }
                            .padding(.horizontal)
@@ -430,6 +521,7 @@ struct ExportDataView: View {
 struct SyncSection: View {
    @EnvironmentObject var syncService: SyncService
    @EnvironmentObject var dataManager: ClimbingDataManager
+    @EnvironmentObject var themeManager: ThemeManager
    @State private var showingSyncSettings = false
    @State private var showingDisconnectAlert = false

@@ -475,7 +567,7 @@ struct SyncSection: View {
            }) {
                HStack {
                    Image(systemName: "gear")
-                        .foregroundColor(.blue)
+                        .foregroundColor(themeManager.accentColor)
                    Text("Configure Server")
                    Spacer()
                    Image(systemName: "chevron.right")
@@ -594,6 +686,7 @@ struct SyncSection: View {

 struct SyncSettingsView: View {
    @EnvironmentObject var syncService: SyncService
+    @EnvironmentObject var themeManager: ThemeManager
    @Environment(\.dismiss) private var dismiss
    @State private var serverURL: String = ""
    @State private var authToken: String = ""
@@ -644,7 +737,7 @@ struct SyncSettingsView: View {
                                    .foregroundColor(.secondary)
                            } else {
                                Image(systemName: "network")
-                                    .foregroundColor(.blue)
+                                    .foregroundColor(themeManager.accentColor)
                                Text("Test Connection")
                                Spacer()
                                if syncService.isConnected {
@@ -705,6 +798,12 @@ struct SyncSettingsView: View {

                        syncService.serverURL = newURL
                        syncService.authToken = newToken
+                        
+                        // Ensure provider type is set to server
+                        if syncService.providerType != .server {
+                            syncService.providerType = .server
+                        }
+                        
                        dismiss()
                    }
                    .fontWeight(.semibold)
@@ -745,6 +844,13 @@ struct SyncSettingsView: View {

        Task {
            do {
+                // Ensure we are using the server provider
+                await MainActor.run {
+                    if syncService.providerType != .server {
+                        syncService.providerType = .server
+                    }
+                }
+
                // Temporarily set the values for testing
                syncService.serverURL = testURL
                syncService.authToken = testToken
@@ -997,6 +1103,53 @@ struct HealthKitSection: View {
    }
 }

+struct MusicSection: View {
+    @EnvironmentObject var musicService: MusicService
+    
+    var body: some View {
+        Section {
+            Toggle(isOn: Binding(
+                get: { musicService.isMusicEnabled },
+                set: { musicService.toggleMusicEnabled($0) }
+            )) {
+                HStack {
+                    Image(systemName: "music.note")
+                        .foregroundColor(.pink)
+                    Text("Apple Music Integration")
+                }
+            }
+            
+            if musicService.isMusicEnabled {
+                if !musicService.isAuthorized {
+                    Button("Connect Apple Music") {
+                        Task {
+                            await musicService.checkAuthorizationStatus()
+                        }
+                    }
+                } else {
+                    Toggle("Auto-Play on Session Start", isOn: $musicService.isAutoPlayEnabled)
+                    Toggle("Stop Music on Session End", isOn: $musicService.isAutoStopEnabled)
+                    
+                    Picker("Playlist", selection: $musicService.selectedPlaylistId) {
+                        Text("None").tag(nil as String?)
+                        ForEach(musicService.playlists, id: \.id) { playlist in
+                            Text(playlist.name).tag(playlist.id.rawValue as String?)
+                        }
+                    }
+                    
+                    if musicService.isAutoPlayEnabled {
+                        Text("Music will only auto-play if headphones are connected when you start a session.")
+                            .font(.caption)
+                            .foregroundColor(.secondary)
+                    }
+                }
+            }
+        } header: {
+            Text("Music")
+        }
+    }
+}
+
 #Preview {
    SettingsView()
        .environmentObject(ClimbingDataManager.preview)
--- a/ios/SessionStatusLive/SessionStatusLiveLiveActivity.swift
+++ b/ios/SessionStatusLive/SessionStatusLiveLiveActivity.swift
@@ -42,6 +42,7 @@ struct SessionStatusLiveLiveActivity: Widget {
                            .foregroundColor(.secondary)
                            .lineLimit(1)
                    }
+                    .padding(.leading, 8)
                }
                DynamicIslandExpandedRegion(.trailing) {
                    VStack(alignment: .trailing, spacing: 4) {
@@ -61,6 +62,7 @@ struct SessionStatusLiveLiveActivity: Widget {
                                .foregroundColor(.secondary)
                        }
                    }
+                    .padding(.trailing, 8)
                }
                DynamicIslandExpandedRegion(.bottom) {
                    HStack {
@@ -72,6 +74,8 @@ struct SessionStatusLiveLiveActivity: Widget {
                            .font(.caption2)
                            .foregroundColor(.secondary)
                    }
+                    .padding(.horizontal, 12)
+                    .padding(.bottom, 4)
                }
            } compactLeading: {
                Image(systemName: "figure.climbing")
Author	SHA1	Message	Date
Atridad Lahiji	abb76e454b	iOS 2.5.1 - Fixed Camera Rotation	2025-12-12 00:38:24 -07:00
Atridad Lahiji	8154cd24bb	iOS 2.5.0 - Apple Music Integration	2025-12-08 15:31:09 -07:00
Atridad Lahiji	06bfb02ccc	Update LICENSE	2025-12-08 18:21:35 +00:00
Atridad Lahiji	f82560bb1d	Add LICENSE	2025-12-08 18:20:33 +00:00
Atridad Lahiji	a6508da413	iOS 2.4.2 - Fixed Swipe Action Colours	2025-12-07 01:43:19 -07:00
Atridad Lahiji	50b30442e8	oops	2025-12-03 15:45:05 -07:00
Atridad Lahiji	b365b967b2	Android 2.4.0 - Backend changes :)	2025-12-03 15:41:45 -07:00
Atridad Lahiji	cacd178817	iOS 2.4.1 - Minor Visual Tweaks	2025-12-03 00:10:08 -07:00
Atridad Lahiji	922412c2c2	Bumped build	2025-12-02 17:09:18 -07:00
Atridad Lahiji	acb1b1f532	2.4.0 - Updated Sync Architecture (Provider pattern)	2025-12-02 17:07:52 -07:00
Atridad Lahiji	c8694eacab	iOS 2.4.0 - Colour accents and theming	2025-12-02 15:55:48 -07:00
Atridad Lahiji	57855b8332	Docs updates All checks were successful Ascently - Docs Deploy / build-and-push (push) Successful in 5m14s Details	2025-12-01 17:07:30 -07:00
Atridad Lahiji	6342bfed5c	2.3.1 - Dependency Updates, Better Live Notifications, and Calendar Fixes	2025-12-01 11:46:31 -07:00