USER_CHANGELOG.mdView source

Documentation status: Source-verified for OpenIntelligence v5.0 on August 25, 2026. Entries added or revised this pass are checked against the code and commit that implements them; the vector-loss and self-heal fixes are additionally confirmed by real device console traces captured the same day, not simulator or code reading alone. Anything device-only that has not been traced, including Private Cloud Compute behaviour, is build-verified rather than device-verified and is called out where it matters.

OpenIntelligence User-Facing Changelog

This document provides a chronological history of user-facing changes, highlighting how OpenIntelligence continuously improves transparency, speed, and reliability.

v5.2 - unreleased

The release that turns on Private Cloud Compute. Nothing about how the app reads, searches or checks your files changes; what changes is that one step, the writing of the answer, can now leave the device when it needs to, and only after you say so. Requires iOS, iPadOS or macOS 27.

Plans

  • When a launch discount is running, the plans screen now shows what the price normally is, how much is off, and the day it ends. The App Store does not mark a reduced in-app purchase as reduced, so without this the price simply looks lower and there is no way to tell it is temporary. The app only says a discount is on when the price it is being charged is genuinely below the normal one, so it cannot advertise a sale that is not running.

Private Cloud Compute

  • When a question needs more room than the model on your device can hold, the writing step can now go to Apple’s Private Cloud Compute. Reading your files, searching them, choosing what to cite and checking the finished answer against the passages still happen on your device, exactly as before. Every release since 4.6 has carried this support compiled out, waiting on iOS and macOS 27. This is the first build made with the toolchain that compiles it in.
  • Nothing leaves without asking. Before anything is sent, a sheet shows what would go: how many passages, how large, and why. Allow it once, allow it always, or keep everything on the device. You can also pin routing to On-Device in Settings and the question never comes up.
  • Every answer says where it was written. Expand the metrics bar under an answer to see On-Device or Private Cloud Compute.
  • Apple’s servers keep nothing after the answer. The connection is end-to-end encrypted and the request is not accessible to Apple or to the developer; these are Apple’s stated properties of Private Cloud Compute, and the app adds nothing to the request beyond the passages you approved.
  • Measured on an iPhone with the A18 Pro: roughly 86 tokens per second from Private Cloud Compute, against 27 on the device. Those figures were taken on a local build with the iOS 27 toolchain and are the same figures the earlier release notes cited.

Honesty

  • How It Works and the About screen said the app asks before sending to Private Cloud Compute, on builds that could not send anything. The check they read answered a different question, whether the operating system has Apple Intelligence, which is true of every iPhone that can run the app. It now answers the real one: whether this build can route to Private Cloud Compute. On a system older than 27 those screens say so plainly.
  • The built-in guides, the Glossary and the Settings capability list now describe the build you are running. Each of them picks its wording on the same condition the code uses, so a build with Private Cloud Compute says it is on and a build without it says it is not.

Ratings

  • The app now asks for an App Store rating, once, after your third verified answer. It never asks on launch, never after an answer it could not verify or declined to give, and never twice within four months; Apple’s own sheet decides whether to show at all and caps it at three times a year. If you would rather not be asked, dismiss it once and it stays away.

v5.1 - September 2, 2026

Most of this release is about the Mac, where importing a large document had become slow enough to be unusable. The text recognition changes apply to iPhone and iPad as well.

Built-in Guides

  • The three sample documents now describe the app you are running. They said complex questions were sent to Private Cloud Compute, which nothing in this build does; they listed fewer formats than the app reads; they described the quality modes by where they run rather than by what they change; and they said nothing about importing, which is where most of the recent work went. All three are rewritten from the code: every format, what happens during an import and after a quit, what each quality mode actually changes, the plan limits, the measured speeds, and what Private Cloud Compute will add when it arrives with iOS and macOS 27. If you already imported them, they update in place.
  • The What’s New screen has entries for 5.0.2 and 5.1. Updating to either used to show nothing, because neither release had been written for it.

Appearance

  • The Mac app icon was a square, and its dark version had a blue rim. Every Mac icon slot was a solid square filling the whole tile, with no transparency at the corners. Mac icons are supposed to sit inside a rounded shape with a margin around it, which is why yours looked like a hard tile in the Dock next to everything else. The dark version had a second problem: it had been made by repainting the background behind the bulb without redrawing the edges, so a thin line of the original blue was still there along every outline. Both are redrawn. The iPhone and iPad icons were already correct and are unchanged.

Speed

  • Every PDF page was drawn at four times the resolution it asked for, then copied through an uncompressed image format and back. The Mac used a drawing method Apple deprecated for exactly this reason: it sizes its canvas from the display rather than from the request, so on a Retina screen a page asked for at 3060x3960 was actually drawn at 6120x7920. That result was then encoded to an uncompressed image in memory and decoded straight back, once per page. Measured on this hardware, roughly 370 MB written and read per page, for nothing. The iPhone never did this; its half of the code was already correct. Each page is now drawn once, at the size requested. The wall-clock effect on a full document has not been measured and no speed multiple is claimed here.
  • With the app open and doing nothing, it was re-reading every library’s search index about seventeen times a second. A background timer kept finding one library in a state it could not resolve, and each pass reloaded every index whether or not anything had changed. Over a measured 164 idle seconds that was 2,848 index reads, the same index re-read 288 times. Left running for about three hours it accumulated a backlog of queued work it could never finish and the app stopped responding. Indexes are now re-read only when they have actually changed on disk.

Reliability

  • A large import paused by quitting the app looked like it had lost everything. Reopening showed the document sitting at zero. The work was never lost: the app has always resumed from the last page it committed. But the screen said otherwise, and removing the item is the one action that discards that progress, so the display was steering people toward the only destructive choice available. A resumed import now reports how many pages it already finished.

Text Recognition

  • The app asked the system to guess each page’s language while also handing it a list of thirteen to choose from. Those two instructions contradict each other. Apple’s own guidance is to state the languages when you know them, because the automatic guess is not guaranteed correct, and a wrong guess means text is corrected against the wrong dictionary, which damages it rather than merely slowing it down. The language is now determined once per document from the text the file already contains, and only that language is used.
  • Page images went to text recognition at the highest possible resolution with no downscaling. That is the slowest and most memory-hungry setting the system offers, and it was set deliberately with a comment saying it caught all text sizes. Recognition now scales down to what is needed to read roughly three-point type, which is smaller than the fine print in any real document.

v5.0.2 - August 27, 2026

Mac only. On the Mac there was no way to get a document into the app at all: the Add Documents button opened nothing, and dragging a file onto the window did nothing either. Both are fixed. iPhone and iPad are not affected by this release and are unchanged.

Getting Documents In

  • The Add Documents button opened nothing. The button asked macOS for a file picker at the one moment the system refuses to open one, so the request was discarded and no window ever appeared. The same fault hit the two file buttons inside a chat, where it was worse: those open into a panel that is otherwise empty, so there was no button to fall back to and no sign anything had gone wrong. All three now ask at a point the system accepts.
  • Library Settings was unreadable on the Mac. The screen was being drawn as a narrow strip down the left with a large blank area beside it, squeezed hard enough that words broke apart mid-way — “Documents” came out as “Doc ume nts”. It was built on an older navigation container that macOS turns into a two-pane layout meant for a sidebar and a detail view, which is not what a settings screen wants. It now uses a single column at a sensible width. Other screens still use that older container and may show the same thing; those are being worked through separately.
  • The built-in sample documents were quietly duplicating themselves. When a sample is corrected in a new version, the app replaces your copy with the updated one. It was deleting the original but not any duplicate an earlier update had already left behind, so each round added another. One library ended up with five documents for three samples. This matters beyond tidiness: the app answers out of these documents, so a duplicate meant the same passage counted twice when it decided what to quote. Existing duplicates are cleaned up on the next update, and documents you named yourself are never touched, even if the name looks similar.
  • You can now drag files from Finder straight into a library. This had never worked, because nothing in the app was listening for a dropped file. The whole library area now accepts them, so a drop does not have to be aimed at anything precise, and dropped files go through the same size and quota checks and the same import review as files picked with the button. Folders are not accepted yet, so drop the files from inside them instead.

v5.0.1 - August 26, 2026

macOS 5.0 went to the App Store as an earlier build and is missing everything below. This release brings it level. On iPhone and iPad this is the first 5.x release, so the v5.0 notes below are part of what you are getting.

Speed

  • The Documents tab stopped waiting on a number it never showed you. Opening the tab first went and counted your cached documents, and only then got on with appearing. That count feeds one optional row that is hidden unless the count is above zero — and on the traced device it was zero, so the row was never drawn. The count is now fetched quietly in the background while the tab opens immediately. On the device this was measured on it cost between 29 and 393 milliseconds every single time the tab was opened, and it was the slowest thing in a log of nearly six thousand lines. Nothing about your documents, your libraries or search changed; the tab just stops waiting to be told something it does not display.

Your Hardware

  • Rotating the device left black rectangles around the floating hardware readout. The readout lives in its own small window that positions itself, and nothing was repositioning it after a rotation. It was also being held inside a portrait-shaped area even in landscape. Both fixed. Dragging it is unchanged, and the chip outlines still stay pinned to where the hardware physically is, because the hardware does not move when you turn the device.
  • The Temperature slider did nothing on one of the three sampling settings, and did not say so. Predictable always takes the most likely next word, so temperature cannot change its output. The slider stayed adjustable anyway. It is now dimmed on that setting, with a note about where it does apply.
  • The Atlas was labelling a medical paper “API Reference”. Cluster names were matched on fragments rather than whole words, so “api” was found inside “therapies” and “term” inside “determined”. A paper about dopamine and serotonin was filed under categories written for software documentation. The same list existed in three places and all three were wrong.
  • “Analyzing corpus…” was never analyzing anything. Every library that was not the one you had open showed a spinner that could not finish, because nothing had been asked to run. Reading a library’s settings means opening it and loading every passage, so doing it for all of them at once would make that screen slow instead. It now tells you it has not run yet, and gives you a button.
  • The library selector on the Database screen is a row, not a menu. With eight libraries, a menu meant a tap to see the options and a second tap to choose one.
  • A tag that appears once in a document no longer describes it. Running headers and page furniture were being turned into tags, which is where “pychatry” came from — a mangled journal masthead read off the top of a page. A word that genuinely describes a document appears in it more than once.
  • Turning performance up was making the app slower at the thing it does most. The four execution profiles set which parts of the chip do the work. Choosing Maximum switched the Neural Engine off and left it doing less than Performance, and when building your search index both Performance and Maximum switched it off, so the middle setting was the only one using the whole chip. Every setting now uses everything the one below it used, and more.
  • The performance selector shows you what it is doing. It was a dropdown that displayed one option and hid the other three. It is now four cards side by side, each showing which parts of the chip it uses, with a plain description of exactly what changes when you pick one.
  • Deep Think never ran a minimum number of passes, and the screen said it did. It said “6 to 8 reasoning sessions”. There is no minimum; it stops as soon as your documents have nothing new to add, or once it is confident enough. One recorded run stopped at five. It now says “up to 8” and explains both reasons it stops early.
  • Macs were being given iPhone-sized limits. The app sorts devices into performance tiers, and the tier below the top one is tuned for phones. Every Mac except the Pro, Max and Ultra models had been placed in it, so a MacBook with 32 GB of memory was processing 1,024 items at a time when it can handle 6,144, and was not scaling with its memory at all. Every Apple chip now sits in the tier its actual capability warrants. Heat is still managed by measuring the machine’s real temperature while it works, which is what was protecting it all along.
  • The hardware panel now shows free memory, and one of its numbers was nonsense. The small floating readout in the corner listed processor, Neural Engine and graphics activity but never how much memory was left, which is the number that decides whether a large import will finish. It does now. Separately, the Hardware Envelope card claimed a limit of 1,073,741,824 simultaneous threads; the real figure is 1,024, and the wrong one came from multiplying three separate limits together instead of reading one.
  • The app understands Apple chips that do not exist yet. Chip support was written out by hand and stopped at the M5, so a Mac newer than that was labelled generically and given settings tuned for an M3. It now works out the generation from the chip itself and scales to match. Four other cases where an unrecognised device quietly switched off four parts of search have been closed as well; the only devices still treated as unsupported are ones that genuinely cannot run Apple Intelligence.

v5.0 - August 10, 2026

Documents were quietly losing parts of themselves, answers were built from a fraction of what was found, and the app was rewriting your library on every launch. This release is the search for all three.

Speed

  • Deep Think answers roughly three times faster. The same question that took four and a half minutes now takes eighty seconds, and comes back slightly longer. It was re-reading the same passages three times over on smaller libraries; it now stops once it has covered the material.
  • The app starts faster. A 43 MB model was being loaded every single launch, before anything appeared on screen, whether or not you went on to ask a question or import anything. It now loads the first time it is actually needed. If you open the app to check something and close it again, that work never happens.
  • Deep Think stops when it runs out of new material instead of re-reading. On a smaller library it would run its full eight reasoning passes even after it had already read everything, repeating the first three passes word for word. Those repeats took about a third of the total time and could not tell it anything new. It now stops once it has covered the material. It still reads every part of every document it retrieved, and it still keeps going when there is genuinely more to read.
  • A document you import no longer loses its searchability to the app’s own housekeeping. The part that makes a document searchable is written as soon as it finishes processing, and the record saying the document belongs to the library is written a little after that. In between, the background job that keeps your libraries consistent across devices looked at a library that appeared to contain nothing, concluded its search index must be junk, and deleted it. The document stayed in the list. Its searchability was gone, and nothing told you. That job now refuses to delete an index that still holds content, and every deletion it does make says why it made it.
  • Switching libraries during an import no longer splits the document from its index. If you started importing a file and then moved to another library while it processed, the file was filed in the library you started in but the part that makes it searchable was written to the one you moved to. The document showed up in the list and in the database view, and then answered nothing, which is the state that made a library look broken for no reason. An import now always writes to the library it started in, however long it takes and wherever you go in the meantime.
  • A library that has lost its ability to answer now tells you, and can repair itself. A library could keep its file list and its text search while the part that actually answers questions quietly went missing, and detection previously ran only when you switched libraries, so it could sit broken for an entire session with nothing to tell you. The check now also runs the moment a question comes back with nothing, and the repair is confirmed working on a real device: detected, rebuilt and answering again in about four seconds. Two related cases, where the repair is blocked because files are still importing, are fixed in code but have not yet been reproduced on a device to prove it, so they are described here as fixed rather than as verified.
  • The app stopped re-reading your entire library to decide it had nothing to do. Keeping libraries consistent across devices means comparing what is on this device against what is in iCloud, and the comparison was reading every passage of every library out of both places before it could decide anything. On one device that came to 43,000 passage records read in a single session, half of them before the app had drawn a screen, and it wrote nothing at all. It now checks whether anything has actually changed before reading, and only does the full comparison when something has. The comparison itself is unchanged, because it is the thing that stops good data being overwritten.
  • iCloud sync stopped re-uploading libraries that had not changed. Every sync pass rewrote each library’s search index whether or not anything was different, and because rewriting a file looks like a change, that started another pass. One launch could do this six times over, writing hundreds of megabytes and queueing half of it to iCloud, all of it identical to what was already there. Sync now compares before it writes, and skips when nothing differs. Nothing about what gets synced has changed, only how often it is rewritten.
  • The source chips under an answer scroll properly now. They used a custom press handler that fought the sideways scroll, so swiping across them sometimes registered as a tap instead. They look and respond exactly the same, they just no longer argue with the scroll.
  • Leaving the chat tab no longer kills the answer you were waiting for. Switching to Documents mid-answer and coming back used to cancel it and discard everything written so far, with nothing to tell you why. The answer now keeps going while you look at something else.
  • The chat no longer loses your place. Scrolling up to re-read an older answer and switching tabs used to slam you back to the newest message on return. It now stays where you left it, and still follows along automatically when you are reading the latest.
  • Atlas keeps showing what it already worked out. Re-opening the tab replaced the whole page with a loading spinner while it recalculated the same result. It now leaves the existing view up until the new one is ready.
  • Answers stream more smoothly. While an answer was arriving, the app re-formatted the entire text from scratch up to fifty times a second, on the same thread that draws the screen. Formatting now happens once, when the answer finishes. The finished answer looks exactly the same, and text stops flickering as half-finished bold and code blocks resolve.
  • Opening the Atlas tab did its work twice. Two separate triggers were both starting the same analysis. Now one does.

Libraries

  • Every action above your documents is now one tap. Add, search, library settings, emptying a library and deleting one were two buttons and a three-dot menu hiding the rest. They are now five icons on a single row, nothing hidden. VoiceOver still reads each one’s full name, including which library a delete would affect, and both delete actions still ask you to confirm and still tell you exactly what will go.
  • Press and hold on a library now behaves like the rest of iOS. It was using a custom gesture that competed with sideways scrolling, so holding a library sometimes scrolled the row instead and nothing told you which one was about to happen. It now uses the standard press-and-hold menu, with the usual preview and haptic.
  • Creating a library no longer suggests a name you already have. The suggested name was based on how many libraries you had rather than what they were called, so after deleting one, the next suggestion could collide with a library still on screen. Accepting it left you with two libraries sharing a name.
  • Importing certain documents could freeze the whole import queue. One kind of file-path lookup could deadlock partway through, and because everything after it in the queue waits its turn, nothing else would import either until the app was force-quit. Found from a live stack sample and fixed at the root.
  • Switching between libraries no longer resets your place or flashes the screen. The library picker at the top of Documents was rebuilt from scratch every time you switched to or from an empty library, which reset its scroll position back to your first library and made the whole screen visibly redraw. Switching libraries now leaves the picker exactly where it was.

Your Documents

  • A document’s auto-generated tags no longer come from its bibliography. The app samples the start, middle and end of a document to work out what it is about, and on a research paper the end is the reference list — so a third of what it read was author surnames. The same paper produced “analysis, depression, dopamine, motivation, serotonin” on one import and “cho, merten, pychatry, zeng” on another, the second set being cited authors and a mangled page header. Reference sections are left out of that sample now, and a capture on August 26 confirms it working: 137 reference-list passages were excluded from the sample on that same paper. The mangled header half of this is not fixed and is still visible. In that same capture the tag “pychatry” appeared again, and it does not come from the bibliography at all — the journal prints its name sideways down the edge of every page, the scanner reads that sideways strip badly, and the result is treated as a heading. That is a separate defect in how page furniture is read, it is recorded, and it is not claimed as fixed here.
  • Tables in Word documents were being thrown away. Each one was read into rows and then dropped, so a document could import looking fine with all of its numbers missing.
  • Images keep their layout. Every image became one unbroken line of text before anything downstream could read it.
  • Photographing a page now matches importing it. Camera captures came out as flat text where the same page imported as table cells.
  • Scanned pages report their scanning honestly. A fully scanned PDF used to tell you it had scanned zero pages.
  • Text from a PDF page is no longer shuffled into the wrong order. Lines were put in sequence by a comparison that treated any two lines closer together than a fixed distance as being level with each other, and then ordered those by their left edge. That distance was larger than the gap between lines in a typical journal article, so almost every pair of neighbouring lines was ordered by indentation instead of by position down the page, and came out swapped. Every word had been read correctly; a paragraph simply arrived as a jumble of half-sentences, which is why nothing flagged it. Lines now sort by position down the page, and the left edge only settles an exact tie.
  • A page the parser knew it had read badly is no longer repaired and then discarded.
  • PDFs with figures but no tables keep their figures.
  • Pages, Numbers and Keynote files now fail clearly. They were never actually readable; importing one no longer looks like it worked.
  • More than half of every document never reached the part that makes it searchable. A padding setting in the two bundled tokenizer files capped text at 128 tokens against models built for 512, and separately made the length check return the same number for every input, so nothing downstream could notice. Measured with the real vocabulary over 139 live chunks: 90% of chunks were cut short and 55% of all library content never reached the embedder. The cap is gone and the length check counts again.
  • The model that reads meaning was looking at one position instead of the whole passage. all-MiniLM-L6-v2 is trained to average across a passage, and the app’s export read a single position the model was never trained to carry the whole meaning. The vectors were never garbage, which is exactly why nothing caught it: correctly sized, correctly normalised, and encoding far less than they should. Re-exported to average properly, this moved rank-1 retrieval from 0.000 to 0.571 across 21 paired test questions, 12 better and none worse.
  • Libraries you already have will now offer to rebuild their search index, once. This release changed how your text becomes searchable, twice over: more than half of every document was being cut off before it was ever indexed, and the part that reads meaning was looking at one position in a passage instead of the whole thing. Anything indexed before this update was built the old way. The app could not tell the difference before and would have left those libraries quietly worse forever. It now notices and offers a rebuild, which you can take when it suits you — nothing is deleted, and the library keeps working in the meantime.

Answers

  • A long answer is no longer replaced by a one-line stub. After the app writes a long answer, a final stage re-reads every claim in it against your documents. That stage was given a smaller budget than the answer it was checking, so on a long answer it could be shown as little as one and a half percent of it and then replace the whole thing with a fragment. It now keeps its share of the budget for the answer rather than letting the evidence take all of it, and if it still cannot see enough of the answer to judge it fairly, it declines and leaves the original alone.
  • The app stopped treating research papers as parts catalogues. A question about dopamine was being classified as a specification lookup, because the list of words that signal “this person wants a spec value” contained “min” and the app was matching it anywhere in the text rather than as a whole word. Dopa-min-e. That switched on scoring built for datasheets, which promotes tables and lists over prose, and in a journal article the tables and lists are the reference section. The same fault made “often” and “after” look like feet, and “example” look like amps. Reference markers such as “behavior.42” were being read as part numbers.
  • Reference lists no longer get cited as sources. A bibliography is the worst possible evidence and one of the best keyword matches: a page of citations about dopamine says “dopamine” many times and states no fact about it. Two of twenty sources in a real answer were citation entries. The app now recognises the shape of a reference list and ranks it below prose, while leaving a genuine question about what a paper cited alone.
  • Search ranks section headings again. A weighting mistake had dropped section paths out of ranking entirely.
  • Evidence that retrieval had already found is no longer discarded when sentence extraction matches nothing.
  • Long questions can now reach Private Cloud Compute. They were being kept on device precisely when they were too big for it.
  • The evidence behind an answer was being put in an undefined order. After the app ranks passages, one more pass re-orders them so that a passage with a clear advantage can outrank a merely similar one. The rule it used compared two passages as equal when their scores were close, and as different when they were far apart — which sounds reasonable and is mathematically inconsistent, because three passages can each be close to the next while the outer two are far apart. Given a rule like that, the sort has no defined answer, and the evidence order came out effectively arbitrary. It now uses a rule that always agrees with itself.
  • Deep Think was writing its answer from a fraction of what it actually found. It could retrieve the right passages and then discard most of them before writing a single word of the answer, including the single best one it found. It now keeps what it retrieved and, in the technical detail view, says exactly what it chose to leave out and why.
  • An answer that cites your documents can no longer be replaced by one that cites nothing. After writing an answer, the app sometimes tries to improve it, and a rule exists to stop a polished-but-unsourced rewrite from displacing a properly cited one. Two holes in that rule are closed. One editing pass was allowed to replace the answer on length alone, without the citation check — and that pass is the one most likely to strip citations, because it is explicitly told to remove unsupported claims. Separately, the citation counter only recognised sources written as [1] and not as (1), so an answer that cited everything in the second style counted as citing nothing, and the protection switched itself off.
  • An answer can no longer tell you your documents are silent while quoting them. The check meant to catch a bad answer was only confirming that its citation numbers pointed at real passages, which they did — so an answer that said “the documents contain no evidence of this” while citing twenty of them was certified at 88% confidence. That specific contradiction is now caught and the answer is regenerated. An honest “I couldn’t find this in your documents”, with nothing cited, is untouched — that one is true, and it stays.
  • Citations now always point at a source that’s actually there. An answer could cite a source number past the end of its own source list, and nothing caught it. Citations are checked against the real list before you see them, and the confidence score can now report a genuine failure instead of always settling on a reassuring middle number.
  • Combining keyword and meaning-based search stopped losing to keyword search alone. The two search methods are supposed to complement each other, and instead the combined result was ranking worse than keyword search by itself. The keyword search’s best matches can no longer be crowded out before the two are compared.

Your Sample Documents

  • The three sample documents described things the app cannot do. They claimed Pages, Numbers and Keynote support, credited the wrong framework, and documented a screen that does not exist. The app answers questions out of those documents, so a wrong sentence became a wrong answer.
  • If you already had them, they update themselves once. You will see a short re-import the first time you open Documents, and a notice explaining it. Nothing you imported yourself is touched, and samples you deleted stay deleted.

Settings

  • Settings is a searchable list instead of one long scroll. Fifteen stacked panels became about ten rows in sections. Nothing was removed. Type “temperature” and you land on it.
  • The generation controls are reachable. Temperature and response length were built with no way into them. Settings → Advanced, one tap. Both work on device and on Private Cloud Compute.
  • You can choose how the model picks its words. Top-K, Top-P or Greedy. The app used to decide for you and always picked the same one, so the Top-P slider did nothing. Unchanged unless you change it.
  • Answers can be made reproducible. Turn on “Reproducible answers” and the same question against the same library returns the same answer every time. Useful if you are checking work, or comparing two libraries fairly.
  • Controls that never affected Apple Intelligence now say so. The three penalty sliders apply to a self-hosted model, not to on-device or Private Cloud Compute answers.
  • Five switches that did nothing are no longer switches. Writing Tools, Speech Analysis, Translation, Screen Awareness and Image Playground are real and always on. The toggles never controlled them.

Every Word, Explained Where You Read It

  • Tap any figure the app shows you and it tells you what it means. “38 TOPS”, “32/batch”, “768 search”, “Chunks”, “Vectors”. Where they already are, without leaving the screen.
  • Two explanations for each, not one. A plain one first, and the mechanism underneath if you want it. Turn the technical version on once and it stays on everywhere.
  • The four import stages explain themselves while they run. Extract, Chunk, Embed and Index are all tappable during the import you watch on first launch.
  • Nothing is buried. Settings has the full list under Plain English, searchable, including by the technical name if that happens to be the word you know.
  • Tapping a Plain English term now reliably opens its definition. It could animate as if it were opening and then leave you looking at the same list, and backing out could land you on a blank screen. Terms now open the same way every other definition in the app already did.
  • Plain English covers a lot more of the app now. Seven new entries: the difference between Standard, Deep Think and Maximum, where an answer actually gets written, and the trust cluster — confidence, fidelity, the live verification checklist, and what the red “Abstained” badge means. Confidence and fidelity in particular are two different measurements shown together with nothing previously explaining that they can disagree, or why.

Your Libraries

  • “Remove Local Copies” is now “Remove All Documents”, because that is what it did. It never only removed local copies. It deleted those documents from iCloud and from your other devices too, while telling you Sync Now could bring them back. It could not. The wording now says what happens, and names the library it applies to.
  • Deleting one document said the same untrue thing, and its button is now just “Delete”.
  • Emptying a library used to leave things behind. The documents stayed in Spotlight search, and their files stayed on disk taking up space. Both are cleaned up now.
  • Moving a library off iCloud asks first. One tap used to remove that library’s copy from iCloud with no warning at all.
  • The Documents toolbar no longer hides half its buttons off the edge of the screen. Library Settings, and the two destructive actions, now live in one menu you can see. Visualize is gone from that row, because it only switched you to the Atlas tab that is already at the bottom of the screen.
  • Two libraries with the same name can be told apart by a short code on the chip.
  • Library chips in Semantic Search no longer show storage buttons that did nothing.

Your Database Tab

  • You can look at any library from here. It used to offer only “All Libraries” or whichever library happened to be active, so seeing a different one meant going to Documents, switching, and coming back. Every library is now in one menu.
  • “All Libraries” actually shows all of them. The document list underneath used to show only the active library no matter what you picked, and never said which library you were looking at. It says now.

Library Settings

  • Changing the embedding model no longer wipes your vectors before you agree to rebuild them. It deleted them at Save, then asked, and choosing “Later” left the library holding documents it could not search.

  • The chunk size sliders now stop where the app actually stops. They went up to 600 words and 200 overlap while importing quietly capped them at 260 and 50, so over half of each slider did nothing. If you had set 400, you were already getting 260.

  • The chunk size controls now say you should not touch them. The app already picks a chunk size from the kind of file you imported, smaller for code, larger for reports and transcripts. Setting these by hand replaces that with one size for everything in the library.

  • Two descriptions on that screen were not true. One said chunks are split by comparing meaning between sentences; that never runs. It splits on section headings and a fixed list of ten English phrases, and the screen says so now, including that the list is English only. The other described the storage format the app stopped using.

  • Deleting a library from its settings screen no longer half-works. If iCloud refused the delete, that screen used to remove the library from this device anyway, so the next sync brought it back and you were left thinking it was gone. It now stops, keeps the library, and tells you why.

  • The two destructive actions no longer look like the same button. They sat next to each other, both red, both a bin icon, and one empties a library while the other removes it. They are now “Remove All Documents from X” and “Delete the X Library”, with different icons and a divider between them.

  • “Cached Documents” is hidden until there is something in it. It was always empty, because the feature that would fill it has not been built yet.

  • On a Mac, a Shortcut running in the background could send a question to Apple’s Private Cloud Compute with nobody there to approve it. The check that requires you to be looking at the app was only ever running on iPhone and iPad. It runs on Mac now.

  • A question is no longer sent to the cloud when the app cannot tell how much cloud quota is left. It now answers on this device instead of guessing.

Things The App Was Claiming That Weren’t True

Settings describes what the app is doing while it answers you. Several of those lines described things the code does not do, so they are gone or corrected.

  • Three places in the app still described Private Cloud Compute as something it does today. The App Store text and the README were corrected in August; the copy inside the app was not. The Model Info card advertised an “On-device model + PCC server” because it checked whether Apple Intelligence was available rather than whether PCC was. How It Works said the app “asks whether to send that single request” to PCC, which it never does in a shipping build. And the sample documents the app reads back to you as fact carried a section headed “When does PCC activate?” beginning “The app routes to PCC automatically”. All three now describe the build you are actually running, and will describe PCC in the present tense again on a build that contains it. The measured speed figure was kept and labelled with the build it came from rather than deleted, because it is real.
  • Settings listed eight agentic tools, and all eight were the wrong ones. Four tools are actually wired up. Those four are now what it names.
  • Two advertised features did not exist, and are no longer advertised.
  • The model picker listed a tier the app cannot select.
  • Speed figures that were never measured have been removed, including from the sample documents the app reads back to you as fact. Where the underlying work was real, it is now described by what it does instead of by a number.
  • Every remaining capability line was checked against the code that would have to run it.

The App Itself

  • The upload status stops breaking its own words in half. With the controls beside it taking the room, “Processing uploads” could render as “Process / ing / uploads”. It is the one piece of chrome on screen during every import.
  • The app icon now follows your device’s dark mode. The existing light mark stays the same, and a matching dark appearance is selected when your device uses dark mode.
  • Your device is identified correctly. iPhone 17 and M5 hardware reported itself as “A12 or Older” with limited performance.
  • The first screen no longer cuts off its own text. Half the headline and all three example questions were being truncated.
  • The chat controls match each other, and the mode menu explains itself. It also shows which mode is active, and how many Maximum runs you have left before you pick it.
  • The hardware readout follows a live answer and no longer stays lit after you stop one.
  • The screen readers can reach the hardware panel properly. Its figures used to be read as one long block; each one is now its own element with its own definition.
  • Answers that ended in bold or italic text no longer come out broken. The last two characters were being cut off, which left the formatting unclosed and bled it into the rest of the screen. The clearest case was the notice you get when an answer could not be verified: its closing bracket was always missing.
  • The embedding view no longer claims your vectors have 512 numbers when they have 384. It reads the real number from the library you are looking at, which differs depending on which embedding model that library was built with.

v4.9 - August 2, 2026

Documents no longer disappear after importing, and libraries carry their work between devices instead of asking you to redo it.

Your Libraries

  • Fixed documents disappearing shortly after import. A document that finished importing while the app was saving your library could be dropped from the list, even though it had imported correctly. This affected a single device as well as several, and it is what made the sample documents unreliable.
  • Documents processed on one device no longer need re-importing on another.
  • Libraries no longer appear to lose documents while iCloud is still catching up.

iPhone and iPad are coming from v4.7, so everything under v4.8 below ships here too. On Mac, v4.8 was already released, so only this section is new.

v4.8 - July 31, 2026

Deep Think and Maximum were not wired up correctly in previous releases. This release fixes that, and everything it uncovered.

Deep Think And Maximum

  • Both modes now reason across your documents. Previously they returned Standard quality answers after a much longer wait.
  • Answers cite their sources in every mode. Maximum produced none at all.
  • Both stop once they stop finding new material, typically halving Maximum’s run time.
  • A single failed pass no longer ends a query.
  • Resolved “The selected model isn’t available right now.”

Privacy And Routing

  • On-Device now covers the entire query, including the final answer.
  • The model picker governs every mode. It previously reached Standard only, so Deep Think and Maximum fell back to a default.

What You See

  • The live pipeline names each stage correctly, including verification and query rewriting.
  • Reasoning detail wraps instead of cutting off mid-sentence.
  • Follow-up suggestions come from the answer rather than stray words.
  • Raw model output no longer appears in answers.
  • Passes skipped for having no relevant text are shown instead of leaving gaps.
  • An answer reporting that your documents do not cover something is kept, not replaced with generic help text.

Also

  • Document import works on Mac. The file picker there was a placeholder.
  • Opening the app after an update now shows what changed.

v4.7 - July 28, 2026

  • Honest Route Labels: Labels now say exactly where each answer ran: on your device, or Apple Private Cloud Compute with your permission. Nothing claims more than the system can verify.
  • Steadier Document Understanding: The key ideas pulled from your documents now come out the same every time, for more consistent search and more reliable connections across files.
  • Route Verification: New internal checks confirm that every answer’s recorded route matches what actually ran.
  • Removed Unsupported Model Claims: Settings no longer advertises selectable 3B or 20B on-device models, or a parameter-count based capability chip. (Correction to earlier releases: the public SDK exposes no such selector. Apple’s larger on-device model is real and managed by the operating system, but no app can choose or observe it.)

v4.6 - July 15, 2026

  • Smarter Private Cloud Compute Decisions: Queries now retrieve evidence locally before choosing a model route. PCC is used only when the final evidence and context budget justify secure cloud synthesis; missing evidence never causes escalation.
  • Exact Cloud Consent: The confirmation sheet describes why PCC was selected and shows the size of the minimized evidence payload that would be transmitted. Background actions never wait on a hidden consent prompt.
  • Model Choice That Stays Put: Hybrid, On-Device, and PCC now describe the policy you selected, not whichever route happened to run last. Hybrid remains selected after a PCC answer and after relaunch.
  • Route Badges on Answers: Every Apple-model answer identifies the route that completed it: on-device, PCC, or on-device fallback. The badge opens the existing detailed route receipt.
  • Reliable Local Fallback: Hybrid and explicit PCC requests fall back on-device when consent, network, entitlement, quota, or PCC availability blocks cloud execution, provided streaming has not meaningfully begun. The answer is labeled as a fallback instead of silently changing routes.
  • Remembered PCC Choice: Always Allow and Never Allow persist across relaunches. The app no longer opens a generic PCC sheet on startup; permission is requested only for a real finalized evidence package.
  • Clear GPU Execution Profiles: Efficiency, Balanced, Performance, and Maximum replace the misleading percentage control and align Settings with the work the app can actually route to GPU-capable paths.
  • Accurate Route History: Saved response metadata distinguishes intended, attempted, actual, fallback, and completed execution paths.
  • Truthful Model Reporting: The “Advanced” on-device model preference now reports the actually executed model route in telemetry and diagnostics. (Correction to earlier releases: the current OS SDK exposes no separate 20B on-device model API; the Advanced preference executes the standard on-device model.)
  • Apple-Approved PCC Capability Enabled: The v4.6 source entitlement is enabled and the app verifies the signed process entitlement before constructing Apple’s native PCC model. Signed iOS 27 physical-device and TestFlight validation remains pending.
  • Hardened Knowledge-Index Migrations: Database schema migrations are driven by a fixed, code-owned migration catalog, eliminating a class of malformed-schema risk.
  • Ingestion Stop Now Persists: Closing or discarding an ingestion queue prevents those exact jobs from returning after iCloud reload. Automatic empty-index repair runs one library at a time and remains disabled for that library on the device where you dismissed it until you explicitly import or rebuild again.
  • Restored Test Coverage: The unit-test target removed in an earlier release is restored, with regression suites pinning embedding, parsing, citation, and launch-argument behavior.
  • PR Backlog Consolidation: All 43 open automated pull requests were audited end-to-end; the valuable changes were reimplemented cleanly in this release and the remainder documented and closed.

v4.5.1 - July 2, 2026

  • Parallel PDF Ingestion Concurrency Fix: Resolved concurrency race conditions and deadlocks on Apple Silicon by introducing thread-safe NSRecursiveLock serialization around CoreImage image generation, preventing concurrent Metal context crashes during multi-page parallel processing.
  • Silicon-Native Core AI Embeddings: Compiled and bundled the EmbeddingModel.aimodel format inside the package resources. This activates Apple’s zero-copy memory paths for 40%+ faster sentence embedding execution natively on Apple Silicon. Included a companion model compilation utility (scripts/compile_core_ai_model.py) to easily convert PyTorch model graphs.
  • Flexible Settings Saving: Enabled saving of embedding configuration options when a provider is unavailable at save-time, allowing runtime fallback routing (e.g. Core AI falling back to Core ML) to resolve and execute cleanly.
  • Silicon HUD Layout Correction: Restored the iOS Silicon HUD position back to its original layout coordinates (x: 45, y: safeAreaInsets.top + 85), and configured the HUD legend to dynamically shift to the right (x: 345) when the conversation history sidebar is visible to prevent overlap.
  • Private Cloud Compute Fallback & UI Safeguard: Configured dynamic Hybrid (Automatic) model routing to check for active developer entitlements before selecting Private Cloud Compute, ensuring seamless fallbacks to local models and eliminating routing delays. Greyed out and disabled the PCC option in the header model preference selection menu until the official developer entitlement is active.
  • Historical Advanced Picker Correction: The earlier RAM-gated “20B Advanced” label was not backed by a distinct public SDK model selector. v4.6 removes that active claim and migrates the saved preference to the public On-Device target.

v4.5 - July 2026

  • Rust-Backed Tokenizer Engine: Replaced the legacy pure-Swift tokenizer with a highly optimized Rust-backed swift-tokenizers engine. This delivers much faster document tokenization and exact byte-level character offset tracking for citations. (A “100x speedup” was quoted here originally; it was never measured and was withdrawn 2026-08-06.)
  • Ingestion Pipeline Stability: Fixed FTS5 index corruption and page offset mapping bugs during streamed ingestion of large documents. Large files are now fully searchable.
  • Core AI Diagnostic Options: Stabilized Silicon-native Core AI sentence embeddings on iOS 27+ / macOS 27+ with robust model readiness indicators and detailed build/OS error diagnostics in settings.
  • CI/CD Pipeline Upgrades: Updated cloud build environments to macos-26 to natively support Xcode 27+ and Swift 6.2+.

v4.4 - June 2026

  • Evidence Threads: Introduced durable conversational threads. Chat sessions and their active citations, metadata, and responses are now persisted on disk, eliminating dynamic ephemerality.
  • Slide-Out Thread Sidebar: Added a premium, spring-animated slide-out menu to view, create, switch, and delete research threads. Features full swipe-to-delete support and active-selection highlighting.
  • Design System Parity: Structured the new sidebar using the app’s native visual tokens (DSColors, DSSpacing, DSTypography), rendering a visually integrated, sleek interface on both iOS and macOS.
  • Thread Storage: Threads initially shipped in isolated local-only storage. (Updated July 2026: thread storage has since moved into the app’s workspace storage and now syncs across your devices via iCloud Drive using safe, coordinated file writes. If you edit the same thread on two devices at nearly the same time, the most recent change wins.)
  • Engineering Diagnostics View: Retained the debug view and mocked thread triggers inside the Developer Diagnostics Hub to inspect and verify thread persistence.
  • Native Private Cloud Compute Support: Integrates route-policy support and diagnostics to escalate complex queries to Apple’s secure Private Cloud Compute server enclaves on iOS 27 / macOS 27+ for supported and entitled builds, with graceful automatic fallback to local on-device execution when unavailable.
  • Pro Annual Pricing & Free Trial: Calibrated the Pro Annual subscription to $29.99/year (representing a 58% savings vs monthly) and introduced a 7-day free trial.
  • Discontinued Document Pack Add-on: Discontinued the consumable Document Pack add-on, removing related UI cards, quick-refill views, and purchase flows.
  • Direct Review Prompts: Streamlined the app-rating experience by triggering Apple’s native review prompt directly at key “happy moments” (like tapping Thumbs Up), eliminating the intermediate alert dialog.

v4.3 - June 20, 2026

  • Transparent Verification Engine: When the AI abstains from answering due to lack of evidence, it will now gracefully provide its drafted reasoning with a prominent [Needs Verification] warning, rather than hiding the drafted answer entirely.
  • Accurate Telemetry Status: Fixed a minor UI bug that caused the Verification Gates status panel to incorrectly light up red (as “Failed”) during perfectly healthy standard queries.
  • Instant Library Scrolling: Fixed a scroll-lag issue when browsing large libraries, by caching row identifiers instead of recomputing them on every row draw.
  • Faster Answer Generation: Rebuilt the context aggregation math so deduplicating large evidence sets no longer slows down as the library grows. Answers generate substantially faster.
  • Enhanced Reliability: Simplified the underlying AI routing engine to be exclusively reliant on native Apple Intelligence, resulting in fewer context errors.

v4.2 - June 2026

  • Modernized UI: Completely rebuilt the live telemetry dashboard with premium frosted glass and interactive haptic feedback.
  • Dynamic Verification Gates: The visual HUD for RAG telemetry now adapts its pipeline dynamically based on your active RAGQualityMode.
  • Fixed Chat History Persistence: Resolved an issue that sometimes skipped loading your previous chat history during a cold boot.
  • Granular Hardware Telemetry: The Execution Badge now dynamically fetches and displays exact onboard RAM allocations alongside TOPS processing power.
  • Accuracy in Retrieval Metrics: Corrected UI labels to differentiate between semantic Database Matching (Vector Similarity) and active LLM reasoning thresholds.

v4.0 & v4.1 - WWDC26 Apple Intelligence Update

OpenIntelligence version 4.0 & v4.1 is a major Apple Intelligence modernization and refinement pass currently live on the App Store. The release touches every major component of the user experience, from the local-first execution model to transparent citation details, visual evidence cards, and Siri/Shortcuts system integration.

This document consolidates this major release cycle into a single, cohesive user-facing log, highlighting the Apple Intelligence native foundation alongside a GPU-accelerated ingestion pipeline, Metal vector search performance, live reasoning telemetry, and database protection.

The practical user story is simple: OpenIntelligence now does a better job showing what evidence it used, where it ran, and how much source support it found before you trust an answer.

Why WWDC26 Matters Here

WWDC26 shifted the platform architecture by pushing core AI capabilities into system-level frameworks. For OpenIntelligence, this unlocked several important system resources:

  • Apple Foundation Models: Native LanguageModelSession instances, structured generation, token budgeting, and route-policy layers.
  • Apple Private Cloud Compute (PCC): A secure cloud route for complex or context-heavy work, ensuring cryptographic privacy.
  • App Intents & App Entities: Integration with Siri, Shortcuts, and system services for reading, listing, and indexing documents.
  • Visual Intelligence: A platform route to import OCR and camera captures as active RAG evidence.
  • Core Spotlight: Deep system-level indexing of document chunks and sections.
  • Core AI: Execution pathways for local custom models.
  • Liquid Glass: A modern visual design system featuring responsive glass effects.

What Users Will Notice First

  • Transparent Verification UI: Responses are explicitly labeled so you can see if they are Source-Locked (fully supported by your documents), Partially Supported, or Lacking Sufficient Evidence.
  • Model Routing Visibility: The status pill in the header shows you exactly where your query is targeted to run: On-Device (standard questions) or Private Cloud Compute (complex or long-context questions, falling back locally if the build lacks the required cloud entitlement).
  • Live Reasoning Telemetry: You can watch the model’s active thinking loop in real-time inside the bottom metrics bar as it organizes thoughts, resolves routing, and writes answers.
  • Lag-Free Visual Transitions: The processing dashboard and overlays transition smoothly using GPU-accelerated effects, eliminating visual stutter during document imports.
  • GPU-Accelerated Local Vector Search: Local vector similarity calculations run on Apple Silicon hardware accelerators using custom Metal pipelines. (A “4x” figure was quoted here originally; it was never measured and was withdrawn 2026-08-06.)
  • Clean Discarding & Deletion: Canceling or deleting an in-progress import now triggers a cascading purge that completely removes file fragments, database records, and Spotlight search indexes, ensuring no orphaned data is left behind.
  • Grammatically Correct Suggested Questions: Suggested follow-up questions are grammatically clean and diverse across different sections of your library.

Key Improvements

1. Smarter On-Device vs. Private Cloud Compute Routing

  • Dynamic Policy: Local execution is preferred for standard queries to protect battery life and latency. Heavy reasoning queries or large files are dynamically targeted to route to secure Private Cloud Compute, with automatic local fallback if the entitlement is not present.
  • Under the Hood Details: Tap the header status pill to open a popover detailing the active model name, token budget usage, and explanations of Apple’s PCC privacy guarantees.
  • Direct Route Metrics: The status bar displays telemetry from the actual resolved routing engine rather than an estimation based on response latency.

2. Grounded Answers and Citation Integrity

  • GroundedAnswerView: Presents cited answers clearly, making it easy to map each statement back to its specific source document.
  • Visual Evidence Cards: Image imports, camera scans, and PDF figures render inside the chat bubbles as OCR-derived evidence.
  • Fidelity Status: Clearly displays the verification level of every response, helping you decide how much to rely on the generated answer.

3. Better Recovery When Generation Misbehaves

  • Empty Response Fallback: If a model returns an empty response, the RAG service now routes into a reliability fallback instead of treating the entire query as unavailable.
  • Partial-Draft Preservation: If streaming produced a useful partial answer before a failure, the app preserves that text instead of replacing it with an empty or generic failure result.
  • Rate Limit Safeguards: Rate-limited or concurrent Apple Foundation Model failures get a short retry path before falling through to recovery behavior.
  • Stricter Grounding Repair: Stricter repair pathways handle context overflow and missing citations, prompting abstention when grounding support is too weak.

4. UI Telemetry & Render Optimizations

  • Thinking Stream: The ThinkingStreamView shows live feedback during reasoning phases so you are never left wondering if the app is frozen.
  • GPU-Driven Overlay: Ingestion overlay animations utilize hardware-accelerated opacity and scale transitions, preventing frames from dropping during heavy background indexing.
  • Massive Document Stability: Resolved a critical bug where opening the app after ingesting massive documents (e.g., HOA docs) caused an instant crash or UI freeze. Ingestion logs are now lazily loaded and capped to prevent unbounded memory allocation and excessive view generation on launch.

5. Suggested Questions & Grammar Safeguards

  • Diverse Suggestions: The query planner isolates unique sections of your documents to guarantee follow-up questions cover a variety of topics.
  • Grammar Filter: Uses Apple’s native language taggers (NLTagger) to analyze parts of speech and filter out OCR layout noise, verbs, or incomplete phrases from suggested prompts.

6. GPU & Neural Engine (ANE) Pipeline Optimizations

  • Adaptive Pre-Scan: Automatically pre-scans documents before ingestion. Clean digital PDF pages bypass expensive Vision OCR pipelines completely, achieving up to a 20% processing speedup.
  • GPU Resolution Scaling: Scales document rendering resolution dynamically based on font size risk, reducing document parsing memory requirements on device silicon.
  • Hardware Telemetry: Integrates haptic and visual metrics feedback for Vision OCR, vector embedding generation, and LLM inference.

7. Database Safety & Zero-Remnant Discarding

  • Anti-Corruption Writes: Vector database disk saves write to a contiguous memory buffer and replace database files atomically, preventing corruption if the app reloads during ingestion.
  • Zero-Remnant Purge: Deleting or discarding a document cleanly deletes all corresponding vector data, FTS5 database indices, Spotlight entries, and local files.
  • Sync Tombstones: Leverages deletion logs (deleted_documents.json) to prevent deleted documents from being revived during cross-device syncing.

8. System Integrations: Spotlight, Siri, and Shortcuts

  • Deep Spotlight Indexing: System Spotlight search can search and index down to specific document chunks, sections, and figures.
  • App Intents: Persisted document and library entities are exposed to Siri and Shortcuts. You can ask Siri to summarize, compare, or search documents directly.
  • Visual Intelligence OCR: Captures image inputs and extracts their text as active evidence in the RAG pipeline.

9. App-Wide UI, Onboarding, and Workflow Improvements

  • Onboarding Progress: Updated the checklist and imports dashboard to display live stages, extraction progress, vector generation counts, and a timer publisher for smooth elapsed-time tracking.
  • Live Activities: Integrated Live Activity support to show background import status directly on the lock screen and Dynamic Island.
  • Sample Document: Renamed the sample document to “OpenIntelligence Product Guide” to align with onboarding instructions.

10. Retrieval, Summaries, and Evaluation Quality Gates

  • Evaluations Framework: Built a suite to measure retrieval recall, citation precision, exact-value accuracy, and hallucination rates against strict quality gates before updates are shipped.
  • RAPTOR-Lite Routing: Added summary routing to handle high-level document overviews by querying generated document summaries.

11. Liquid Glass and Visual Polish

  • Universal AppIcon: Added a unified universal AppIcon configuration across iOS and macOS targets, resolving catalog build warnings.
  • Visual density: Standardized margins (14pt) and tighter corner radii for message bubbles (16pt) and cards (12pt) to create a denser, more cohesive Liquid Glass UI.
  • Model Preference Selector: The original selector is superseded by v4.6’s persistent Hybrid, On-Device, and PCC policies. PCC fallback is now explicitly labeled rather than represented as PCC running locally.