Raycast 1.104.36 · arm64 · menu v1 · 2026-11-16

Clipboard Patch Ideas

Four feature patches that look stably feasible, five families rejected with reasons, and three read-only investigations that would turn the question marks into answers. Nothing below is implemented — each item stays unbuilt until you approve it by name.

Awaiting review

The bar every idea must clear

The retention patch shipped by replacing one branch at 0x1002b7290 (b.ne 54000981 → nop 1f2003d5) because the gate was client-side and anchored to a cstring that exists only for it. That recipe is the standard for everything on this page:

What can never clear it: anything server-validated (a client patch cannot mint an entitlement Raycast's servers verify), anything requiring constructed UI (adding a settings row means authoring new Swift view code into the binary, with no anchor to survive updates), and anything needing new persisted state (pinning, tagging, custom metadata).

Overview

#IdeaValuePatchREStabilityFirst step
1Oldest-first history ordering (your seed idea) MediumSMWeakest of the setInvestigation C
2Retention engine: verify, then exact-day control High / NicheS–MMStrongInvestigation A
3Record-count cap unlock (if a cap exists) Medium*SSStrongInvestigation B
4Large-clip size cap raise (if a cap exists) Medium*SMMediumFind the size check

* Value and effort depend on what the investigation finds — two of the four ideas may not exist in the binary at all, and the investigations say so before anything is promised.

Oldest-first history ordering

IDEA 01
your seedpatch: S RE: Manchor: structural, weakest here

What changes

The history window lists entries oldest to newest, and a fresh capture appears at the bottom of the list instead of the top.

Why it's worth it

Assembling multi-step pastes in copy order — document sections, code chunks, step-by-step instructions — currently means hunting bottom-up through a newest-first list. Reversed, the list reads as the session happened: top is where the copy session began, and grabbing "the first thing I copied this morning" is one glance.

How the patch would look

One site: the history window's fetch or sort, inside the data source that feeds the clipboardHistory command's list. Either a comparator direction or an ordering constant. The patch itself is likely a single instruction; the work is finding the site.

Effort & stability

RE is the bulk of the job — the history window's data source isn't mapped yet. Stability is the weakest of the set: sort and fetch code carries no unique strings, so the anchor is structural (reachability from the history command's data source) rather than semantic. After an update the locator may refuse and need re-derivation. Fail-closed keeps that safe; it just means a cosmetic feature occasionally needs a manual pass.

Critique → improved form

Attack: the first attempt was "patch the sort comparator." But comparators in a list UI are often generic machinery shared by every list — commands, file results, search. Patching a shared comparator reorders all of them, not just history. Fix: target the history-specific fetch, reached through the history command's data source, never a shared sort.

Attack: when a new clip lands, does the window re-fetch (a reversed fetch just works) or append in place (view and fetch then disagree about order)? Fix: the patch must sit at the source of truth, below whatever appends. Investigation C answers which shape the binary uses before anything is touched.

Retention engine: verify, then exact-day control

IDEA 02
highest prioritypatch: S–M RE: Manchor: strong, org-key strings

What changes

Three stages, each smaller than it sounds. (a) Read-only: confirm the pruning engine actually honors Unlimited for a free user — the README's own open question, since the shipped patch unlocked the picker, not yet the engine. (b) If the engine re-checks Pro at prune time, patch that second gate the same way. (c) Optionally: exact-day retention by making the personal path read the org-managed day count — the engine demonstrably handles arbitrary day counts end-to-end, because that is what enterprise-managed installs use.

Why it's worth it

(a) is insurance on the patch already shipped — nothing on this page outranks it. (c) gives bounded retention ("keep two years, then drop"), which Unlimited doesn't: disk hygiene and stale-data hygiene are features of a bound, not of infinity.

Grounding already in hand

The clipboardHistoryLength consumer at 0x1002b4b88; four code refs to organizationClipboardHistoryRetentionDays (0x10157ee28, 0x101581fac, 0x1016202a0, 0x101623344) and one to the policy key organization_clipboard_history_retention_days at 0x10178a418; the option builder at 0x1002b6eec, already fully mapped.

How the patch would look

(b) would be an entitlement branch with the same shape as the one already patched — cmp wN,#1 and a conditional around a Pro check — so the existing locator pattern transfers nearly verbatim. (c) is either a branch retarget so the personal path consumes the org key, or a one-case change in the enum-to-days mapping.

Critique → improved form

Attack: the first attempt was "custom retention beyond the menu." But the shipped patch already unlocks Unlimited — five years adds nothing over forever, so the idea as first conceived is mostly superseded. What survives: the engine may not honor unlimited at all (then patching it is the real completion of the original patch), and exact-day bounds are a different feature from infinity, not a smaller one.

Attack: remapping a menu case ("6 Months" secretly keeps five years) makes the settings UI lie. Fix: prefer the org-key route, which has no menu label to contradict, or accept the mismatch and document it in the patch's own README.

Record-count cap unlock

IDEA 03
if a cap existspatch: S RE: S — smallest job hereanchor: strong

What changes

If the free tier caps the number of stored records separately from duration, raise the cap (bounded, not removed).

Why it's worth it

Unlimited duration is hollow if only the newest N entries survive — a year of retention with a thousand-entry cap quietly discards anything older anyway. Whether this cap exists is unknown; the key name suggests it does.

Grounding already in hand

clipboardHistoryRecords has exactly two code references in the entire binary — 0x1002aa5c8 and 0x1002aa7bc, ~500 bytes apart in the same page, almost certainly the setting's read/write pair. Two sites to disassemble is the smallest investigation on this page.

How the patch would look

If the cap is Pro-gated the way duration is, it's the same entitlement-branch shape already patched, and this becomes the highest-confidence patch of the set — the locator transfers nearly verbatim. If it's a literal (cmp #N at insert or prune), widen the constant.

Critique → improved form

Attack: the cap may not exist — free might already keep unlimited records. Then the idea is moot, and the investigation says so before anything is promised. Attack: raising a count cap grows the on-disk store without bound. Fix: raise to a large-but-bounded value, and let investigation B report how the store grows before picking a number.

Large-clip size cap raise

IDEA 04
if a cap existspatch: S RE: Manchor: unconfirmed

What changes

If Raycast skips or truncates very large pastes when recording history, raise the threshold to a bounded value (for example 1 MB → 8 MB — never removal).

Why it's worth it

Big pastes are exactly what history is for — terminal dumps, long logs, whole files. If they're dropped or cut off, the feature quietly fails where it matters most.

How the patch would look

A size check at record time: a compare against a byte count with a skip branch (cmp #bytes / b.skip). Either NOP the branch or widen the constant.

Effort & stability

RE is the bulk: the check isn't anchored to any known string, so finding it means walking the record path. Stability is medium — it anchors on whatever constants or error strings sit near the check, which the investigation must confirm.

Critique → improved form

Attack: the cap may not exist — Raycast may already record everything. Then there's nothing to do, and the investigation should say so early. Attack: removing a cap outright risks memory and store bloat if entries are held in RAM or indexed. Fix: a bounded raise only, and the investigation reports the memory model before a number is chosen.

Rejected, with reasons

The recursive pass killed more than it kept. What died and why:

Cloud Sync unlock

Server-validated. The retention patch works because enforcement is client-side; sync is checked by Raycast's servers, and no client patch can mint what the server verifies. Impossible, not merely hard.

Pin or favorite entries

New persisted state, new list rendering, new gestures. Feature construction, not gate removal — the binary has no dormant pinning to unlock.

New settings rows — a sort-order picker, a custom-days field

Constructing Swift UI is the most invasive thing a patch can do here, and it has no anchor to survive updates. The ideas above deliberately avoid needing one: a hard reversal instead of a toggle, the org-key route instead of a new field.

Per-entry timestamps in the list

New UI construction. If rows already render dates, there's nothing to do; investigation C will show.

Export history to a file

Needs a new command and UI as a patch — but the history store lives on disk, so an external export script needs no patch at all. Some features belong outside the binary.

Groundwork: three read-only investigations

Each investigation is pure reading — xref_scan.py and disassembly, no writes to the app. Approving one approves reading, not patching; any patch that comes out of one still needs its own yes.