The panel

The overlay

The panel ⌘⌥C brings up: your whole history, your variables and your actions in one searchable list, and the keys that do something with a row once you have found it.

⌘⌥C brings up the overlay, which shows the clipboard history ordered by most recently copied. Type to fuzzy find it. ⌘1–⌘9, ↩ or a click uses the row, and ⎋ closes the panel.

Closing hands the keyboard back to the app that had it when the overlay came up, so ⎋ leaves the desktop as it was found and typing carries on where it left off. The exceptions are dismissals where focus has already gone somewhere: clicking another window puts it there, and ⌘, puts it in Preferences.

However the overlay is brought up, the search field takes focus, so it can be typed into straight away.

The list

As long as what it is listing, and it scrolls. The whole history with nothing typed; every match once something is. Nine rows fit the panel at a time and the arrows carry on past them, with the highlighted row staying in view.

Nine is how many rows a digit reaches — ⌘1–⌘9 and the family of chords beside them — and not how much there is. Every row shows its number, but past the ninth it is dimmed and has no box, since there is no ⌘12 to press. Those rows are reached by arrowing to them, or by typing until they are in the nine.

Every row says when it was copied and, where one was recorded, the app it was copied in. The time is worked out when the row is drawn and then left alone — 5m ago, 3h ago, 2d ago, and just now for anything within the minute. It does not tick, and nothing is said in seconds: a row reading 12s ago that then sat there for a minute would be wrong in a way just now never is.

Rows show how many values an entry has held when it has held more than one.

• An image row shows the image itself, small, with the time, what it is and how much disk it takes, and under that the words read out of it run onto one line.
• A file row shows the icon Finder gives the first file — a thumbnail of it when it is an image — the names — report.pdf, notes.txt and 2 more — and a warning against any that are no longer where they were.
• A variable row is named $name and badged VAR. A list row is named @name, says how many items it holds, and is badged LIST. A hash row is named %name, lists its first keys and how many there are, and is badged HASH; using one pastes its key: value lines.
• An action row shows its keyword and description. Rest the highlight on one for a second and its help page appears under the list, rendered the same way the Actions pane renders it; the next keystroke takes it away again. This also happens for the filter names offered while a pipeline is being typed, which is where "what does this keyword do" is most often the question.

Searching

Variables and actions are matched as well as the history. The order is variables, then the history, then actions, each group best match first.

A variable leads because you named it: typing part of a name you chose says what you are after more plainly than a word that happens to appear inside something you copied, and there are a handful of variables against a history of hundreds. An action goes last — it is what makes a value rather than one of them.

Neither appears until the query matches it, so an empty bar is the history alone, newest first, exactly as before. Triggers are not listed at all: they fire on a copy and are never run by hand.

The three are ranked against each other as groups rather than scored against each other. A copy that matches the query far better than any variable does is still listed under the variables — how well a query fits one candidate says nothing about whether a name you chose beats a copy you made.

Names and contents are matched differently, because they are different questions.

Names — an action's keyword or description, a variable's name — are matched the way a command palette does: the query's characters appear in order but need not be adjacent, so rut finds remove-url-tracking. Each character has to start a word or carry on from the one before it, which is what makes red find url-encode through the r of url and the e and d of encode. A query that appears literally matches wherever it sits, so st still finds abstract, and digits start a word, so b64 finds base64.

Contents — history items, and a variable's value — are matched by term: the query is split on whitespace and each term has to appear literally, in any order. So redgifs finds only entries containing that word, and brew fzf and fzf brew both find a command using the two — the ones holding them in the order you typed come first. Word starts are too loose here, because an entry a paragraph long contains almost any short query scattered through it.

A few more ways to say what you're after:

• "an exact phrase" finds those words together, as written: "out of office". Quotes also search for a word the bar would otherwise read as something else: "url" is the word rather than every link, and "#include", "is:pinned" and "-rf" are found as text.
• /a pattern/ between slashes is a regular expression: /inv-\d+/ finds invoice numbers, /^https?:/ copies that start with a link, /invoice|receipt/ either word. Case is ignored, as it is for words. It is a pattern only when the closing slash ends a word, so /usr/bin is still a path to look for, and quoting it — "/two.*words/" — looks for the slashes and the dot as written. Until you type the closing slash, a line under the bar says the pattern is being searched for as written; one that isn't a valid regex finds nothing, and the line says that instead. Patterns search what you copied, not names.
• OR, in capitals, takes either side: invoice acme OR receipt is what holds invoice and acme, or receipt. A lowercase or is just a word.
• -word leaves out what holds the word, -"a phrase" what holds the phrase, and -/a pattern/ what the pattern matches — more on that below.

A variable matches on its name, or failing that on its value — a match on the value alone always ranks below every match on a name.

How far into a long copy a search reads depends on what you type: words, in any language, are looked for in the first megabyte, so a word near the end of a long log is still found; a /pattern/ in the first 32,768 characters.

Accents you leave out don't matter: cafe finds café, and pho finds phở. Accents you type do: café finds café but not cafe. Each word goes its own way, so naïve cafe finds naïve café. Letters such as ß, æ and ø are letters of their own, so strasse doesn't find Straße.

A copy is also found by its tags. A term that is the whole of one of its tags — url — is answered by the tag, so url lists every link you have copied and url github the links with github in them.

Written with its #, a tag narrows the list instead: #url github shows only links, the way ⌘F does, so actions and variables drop out. #work,#invoice is what carries both, and the kinds work too — #text, #image, #variables. A # word that is no tag you have, like #include, is searched for as text.

Typing the start of a tag offers it: ima or #ima puts a #image row at the top of the list (below any variable whose name matches, so email shows $email before #email), saying how many copies carry it. Press ↩ (or click it) to write #image into the bar in place of what you typed, or ⇥ to write #image, and add another tag. #url,#mac finds copies with both tags, and while you type the second — #url,#ma — the row offers #url,#mac.

A copy is also found by what is known about it: its description, the app it was copied in — safari, or even saf — and for a picture its type and size — png, or 900x600 (or 900×600) for every picture copied at that size. These always come after copies whose contents match, so a screenshot with 900x600 written in it comes before a picture that only is that size, and describing things never pushes what you copied down the list.

A word of an app's name also narrows a search, the way a tag does: chrome github finds what you copied in Google Chrome with github in it.

app: shows only what was copied in one app, on its own or beside anything else: app:safari, app:saf invoice, app:"Google Chrome". The start of the name, or of a word in it, is enough. Actions and variables drop out, as they do under a tag. app: naming no app you've copied from is searched for as text.

window: shows only what was copied in a window with that in its title: window:invoice, window:"Pull request". A browser's window is titled with its page, so this finds copies by the site or document they came from — a number copied off a Stripe invoice is window:stripe, however little the number says for itself. Any part of the title will do, without regard to case or accents; several window: words must all be in it. Rest the pointer on a row, or press ⌘L, to see the title it was copied under. Titles are read with the Accessibility permission, so a copy made without it, or before PasteDaemon kept titles, has none and is never found this way.

lang: shows only code in one language: lang:swift, lang:sql, lang:python, and the usual short names too — lang:js, lang:py, lang:bash. It finds the snippets described under their row as Swift code, SQL query and so on, so unlike typing swift it doesn't also turn up a message about Swift. A snippet you've described in your own words is found by those words instead. The languages are Swift, Python, JavaScript, TypeScript, SQL, shell, HTML, CSS, Go, Rust, Ruby and Java.

Type a qualifier's colon to see what it takes. is:, app:, lang:, sort:, on:, since: and before: each list their values at the top of the list as soon as you type the colon — every state with what it means, the apps you've copied in, and so on, with how many copies each finds — and narrow as you type more. ↩, ⇥ or ⌘1–⌘9 writes one into the bar.

is: shows only copies in a state, and its first letter is enough:

• is:pinned — what you've pinned, found among everything else once you search.
• is:edited — what has changed since you copied it, by a trigger, an action or your own hand, so it has past values to go back to.
• is:triggered — what a trigger rewrote: the link a trigger stripped of tracking, the JSON one tidied. It still counts if you edited the copy afterwards. A trigger that only tagged or described a copy didn't rewrite it, so it isn't counted. Copies rewritten before version 2.5 aren't counted either, because nothing recorded what made them then.
• is:action — what an action or a command you ran changed: upper run on a copy from the overlay, a shortcut or the menu bar. From version 2.5 on, as for is:triggered.
• is:api — what a program changed or put on the clipboard: a script over the API, an assistant, or the Shortcuts app. From version 2.5 on, as for is:triggered.
• is:untagged — what carries no tag you gave it: what is left to file.
• is:formatted — what kept the look it was copied with, so it pastes back styled.
• is:symbol — what holds a symbol: ⌘, ⌥, →, €, ©, ✓. Ordinary punctuation such as $ or + doesn't count, and neither does an emoji.
• is:emoji — what holds an emoji: 😀, 👍🏽, 🇫🇷.
• is:missing — files copied in Finder that are no longer where they were.
• is:secret — what is kept sealed, by a seal action or the Sensitive data copied trigger. A sealed row never matches the words you type, so this is the way to list them.
• is:large — the big ones: a picture or an object of 1 MB or more, or 10 KB of text or more. A link's preview doesn't count.
• is:local — what you kept on this Mac with Keep on This Mac, so it never syncs.
• is:offloaded — pictures, and long copies, taken out of iCloud to stay within the limit. They're still on your Macs, and each shows a dashed cloud. Paste one to send it back up.
• is:guessed — copies with a guessed tag you haven't kept or taken off yet. #trip -is:guessed lists only the copies you filed there yourself.

is:edited is:triggered asks for both. action and api both start with a, edited and emoji with e, and symbol and secret with s, so those take a second letter: is:ac, is:ap, is:ed, is:em, is:sy, is:se, and large and local both start with l: is:la, is:lo.

A - in front leaves things out: -#url is everything but links, -app:slack everything not copied in Slack, -is:pinned everything not pinned, -on:today everything but today's, -is:action everything no action changed, -lang:sql everything but SQL. It works with every one of them and mixes with the rest — #work -is:edited invoice.

In front of a word or a phrase it leaves out every copy holding it: invoice -draft is the invoices that don't say draft, and -"do not send" leaves out what says that. A copy is left out if its description holds the word, too. Only a - followed by a letter or a quote does this, so -1, -3 days, --force and -> are searched for as written. To find -rf itself, quote it: "-rf".

A secret matches nothing here. A variable named with a leading ! is left out of the search entirely — by value, which is the point of one, and by name as well, so that somebody typing aws is not told by the list that there is an $!aws-key. Typing $! in the search bar is the only way to reach one.

Changing how it searches

Everything above is the default. The Search pane in Preferences changes it (Search Settings has the whole of it):

• Order of results. Drag Variables, Tags, Copies and Actions into the order you want them, or use the arrows. ↩ takes the top row, so putting Actions first means a word runs an action. A variable found only by what it holds stays just above the copies.
• Which groups a search lists. Untick Variables, Tags, Copies or Actions to leave them out when you type. With Tags unticked, typing ima no longer offers #image; tags are offered only after a #. With Copies unticked, words alone find no copies, but an empty bar, a #tag, a date, a question and a saved search still do.
• Keep pins on top while searching. On, the pins a search finds come first.
• Keep the last search. On, the overlay opens on what you last searched for.
• Search back. A week, 30 days, 90 days or a year, and a search finds only what you copied or pasted in that time, and your pins. A line under the bar says how many older copies match; ⌘⇧F switches the limit off and on, saying so under the bar, and a date in the search looks back as far as it says.
• Match words typed. Anywhere (mail finds email), At the start of a word (mailbox and Mail.app, but not email), or As whole words (the mail came). A word in quotes, "mail", is still found anywhere, for the one search that needs it.
• Match case. Never, When you type a capital (user finds User, but User finds only User), or Always. For searching code and identifiers. Accents are still ignored, and -word still leaves out anything holding the word in any case.
• Abbreviations find actions and variables. Off, rut no longer finds remove-url-tracking; a name has to hold what you typed, as you typed it.
• Advanced search. Off, OR, -word and /pattern/ are searched for as you type them, for somebody who never uses them and keeps tripping over them. Quoted phrases and filters like #tag and on: still work.
• Search descriptions, apps and picture details, the text in pictures and what variables hold. Switch one off to stop the overlay finding things that way.
• Show copies in Spotlight. On, ⌘Space finds your copies too, and picking one puts it on the clipboard. Off to begin with, and set on each Mac.
• Search the text in copied files. Off until you turn it on. On, PasteDaemon reads the documents you copy in Finder so a search finds them by what they say.

They apply to the overlay, the Trash and your saved searches. The API and the Shortcuts app search the same way on every Mac, whatever is set here.

Sorting

The list starts with what you copied or pasted last. sort: lists it another way:

sort:oldest                  first copied longest ago at the top
sort:newest                  by when each was first copied — pasting doesn't move it
sort:changed                 by when its text last changed
sort:pasted                  the ones you paste most often first
sort:largest                 the biggest pictures and longest texts first
sort:smallest                the smallest first
sort:used                    what you copied or pasted last first — the usual order

The start of the word is enough — sort:old, sort:p. It mixes with everything else in the bar, so #work sort:pasted is your work copies, most pasted first, and sort:largest since:monday is this week's biggest. A link's preview doesn't count toward its size, so a link is as big as its text. Anything else a copy brings along does — cells copied from a spreadsheet are as big as the cells — and its row shows that size beside the character count (3 chars + 14 KB). Under sort:pasted, each row says how many times you've pasted it. Words you type still find the copies holding them in the order you typed them first, and the order decides among those and among the rest. Actions and variables drop out, as they do under a tag, and so does the shelf of pins: they take their place in the order like anything else.

To list your copies in another order every time, choose it under List the history in Search settings. Your pins stay on top, and the rest follow it. A sort: in the bar still wins.

Searching by date

Three words put a date into a search: on:, since: and before:.

on:yesterday                 everything first copied yesterday
on:september                 … in September
on:"2 weeks ago" invoice     copies from that day with “invoice” in them
since:monday                 from the start of Monday on
since:3d                     the last three days
before:2026-09-01            everything older
since:"last month" before:2026-09-15

A date with a space in it goes in quotes. on: means the whole of what the date names: on:yesterday and on:"2 weeks ago" are a day, on:"last week" and on:september a week and a month, and on:"3 hours ago" is the hour from then. since: starts at the beginning of it and before: stops there, so since:monday before:friday is Monday to Thursday.

Dates lean into the past, since a search is of what you have already copied: monday is the last one (today, on a Monday), sept 28 and christmas the last ones too, and november last November until this one comes round. 2026-09-28, 28 sept, sep 2025, 2025, this week, last month, last friday, 3d, 2w and 6h all work.

Picking a date from ⌘F writes it in this syntax for you. What the date was read as appears in the chip beside the bar, as Mon, Sep 28 or since Mon, Sep 28, so you can see it was understood. A date that cannot be read narrows nothing, and the bar says so under it.

It is the day a copy first turned up. Copying the same text again moves it to the top of the list, but it is still found on the day you first copied it.

A date narrows the list the way a tag does: actions drop out, and so do variables unless #variables is what is showing. The copies are listed newest first by when they were first copied.

Showing one kind of thing

⌘F asks what to show: first whether by Tag, Date, App, State, Saved, Language or Sort — press 1–7, t, d, a, s, ?, l or o, or pick one with the arrows and ↩ — and then which. Each row of that first question says what of it is showing now.

What you pick is written into the search bar, as the search that would have typed it: #work, on:yesterday, since:monday, app:Safari, is:pinned, lang:swift, sort:oldest. ⌥↩ (or ⌥ with the digit) picks it to leave out instead, written with a - in front: -#url. Picking it the same way again takes it out. Whatever you'd already typed stays after it, and you can go on typing. So the bar always says what the list is showing — change it by editing it, take it away by deleting it — and the next time you can type it yourself.

By tag

Choosing Tag lists six kinds first — #text, #url, #image, #files, #object and #variables — then every tag you have, each with how many rows it would leave. Type a few letters to find one (tr finds to-read), then pick it with ↩, ⌘1–⌘9 or the arrows. ⎋ backs out without changing anything, and so does ⌘F again.

The kinds are always there, in that order, so ⌘1 is always text and ⌘2 always links. #url, #image, #files and #object are the same tags your copies get on their own, so they find every link, picture, file list and object you have, including ones copied before tags existed.

A link is listed apart from text. A copy that is one web address and nothing else is a link; a paragraph that mentions one is the paragraph. #text is text that is not a link, so nothing appears under both. Actions drop out of a narrowed list whatever it is narrowed to — an action is what makes values rather than one of them. Variables appear under #variables and nowhere else; with nothing typed it lists every one of them.

To see what has several tags, write them #work,#invoice (⇥ finishes a tag and adds the comma); the counts are then for copies carrying all of them. A kind and a tag combine too: #text,#work is the text you tagged work. There is no All — to go back to everything, choose what you're showing again.

Picking writes the tags into the bar — #work,#invoice — in place of any tags already there, and the list then shows only those copies, most recently changed first. Anything else you type searches within them. Like any search it goes when the bar is cleared, and closing the overlay clears it.

By date

Choosing Date offers Today, Yesterday, This week, Last week, This month and Last month, each with how many copies were first copied then. Or type one — sept 28, 2 weeks ago, since monday, before 2026-09 — and it leads the list once it reads as a date. ↩ or ⌘1–⌘9 writes it into the bar as an on:, since: or before: — on:yesterday, on:"last week", since:monday — in place of any date already there.

To go back to every date, delete it from the bar, or choose the same one again. A date and a tag can both be in the bar: the list is then the copies that answer both.

By state

Choosing State offers each of the states — is:pinned, is:edited, is:triggered, is:action, is:api, is:untagged, is:formatted, is:symbol, is:emoji, is:missing, is:secret, is:large, is:local, is:offloaded and is:guessed — with how many copies are in it. Press a digit or the state's first letter (a is is:action, e is is:edited and s is is:symbol; is:emoji is 9, is:missing, the tenth row, is m, is:secret is reached with the arrow keys, and is:large, is l; is:local is reached with the arrow keys, is:offloaded is o, and is:guessed, the last, is g). It is written into the bar in place of any state already there, and choosing it again takes it out.

By app

Choosing App lists every app you've copied from, the one you've copied from most first, with its icon and how many copies came from it. Type to find one. ↩ or ⌘1–⌘9 writes it into the bar as app: — app:Safari, app:"Google Chrome" — in place of any app already there, and choosing it again takes it out.

By language

Choosing Language lists the twelve languages lang: knows, each with how many snippets are in it. Press a digit, the first letter or the arrows; it is written into the bar as lang:swift in place of any language already there, and choosing it again takes it out.

In another order

Choosing Sort lists the seven orders, each with a line saying what it does. The one the list is in now has a tick, and the one set in Copy/Paste settings says default. Press a digit, the first letter or the arrows; it is written into the bar as sort:oldest in place of any order already there, and choosing it again takes it out, back to your default.

Saved searches

A search you come back to can be kept under a name. Type it — tags, dates, apps, states and words, #tax since:"this year" receipt — and press ⌘S. Give it a name and press ↩.

To bring it back, type ? and the start of its name into the search bar — ?tax — and press ↩ (or ⌘1–⌘9, or ⇥). Anything else after a ? — more than one word, or a word no saved search's name starts with — is a question instead. Or choose Saved from ⌘F, which writes the ? for you and lists them all. The search is written back into the bar exactly as you saved it, so you can change it before you go on, and a date like since:monday means this Monday whenever you use it.

They're listed by name. To change one, bring it back, edit it, and save it under the same name: that replaces it. To forget one, highlight it in the list — under ?, or from ⌘F → Saved — and press ⌘⌫. Forgot the wrong one? Press ⌘Z to put it back where it was, as long as PasteDaemon hasn't quit since.

Only a search can be saved — not a command ($1 | upper), which is what an action or a shortcut is for. Saved searches sync with your other Macs along with the rest of your settings, and need a licence.

Asking a question

Type ? and what you're looking for, in plain words — ?the wifi password, ?hotels for the trip, ?the link from yesterday — and the list shows the copies that answer it, closest first. They're found by what they mean, not only by the words you typed: ?hotels finds a booking at an Inn, ?that blue colour finds #3b82f6, and ?screenshots finds pictures.

On a Mac with Apple Intelligence, it then reads the closest few and puts the one that answers the question at the top, with a line under the search bar saying why. That can find an answer that shares no word with the question — ?how much do I owe finds an invoice. Without Apple Intelligence the list is the same, in order of meaning, and the line says why it isn't being asked. ↩, ⌘1–⌘9 and the rest work on the rows as they do on any search, and a row you've arrowed to stays highlighted when the answer arrives.

The search bar's filters still narrow what it looks among: ?#work the contract, ?app:safari that article, ?since:monday the address, ?window:stripe the total. The title of the window a copy was made in is read along with what it holds, so ?the router password can find a bare password copied from a page titled Router admin.

Everything happens on your Mac. Copies kept sealed, secrets and variables are never read, and nothing is sent anywhere. A ? with the name of a saved search still brings that search back. To turn questions off, see Search settings. Asking needs a licence; without one, the line under the search bar says so and the list stays empty.

Asking again

Type ? and press ↑ to bring back the last search or question you took a copy from, and ↑ again for the ones before it — ?the wifi password and invoice #work alike, newest first. Once its results list, ↓ moves down them as usual; from the top row, ↑ carries on to older searches. Pressed before anything is found, ↓ comes forward again, back to the bare ?. Typing ends it.

Only searches you used a copy from are kept — not every one you typed on the way — the last 50 of them. They stay on this Mac, aren't synced, and are forgotten when you clear the history; turning questions off forgets the questions. ↑ on an empty search bar still steps through past commands.

Finding similar copies

On a copy, press ⌘K — or right-click it and choose Find Similar — to list the copies most like it, closest first: the other invoices from the same company, the other bookings for a trip, the other error messages from one log. The search bar shows ?like: and the start of the copy's id, which is how it names that copy, and the line under it says which copy it is.

It's a question like any other, so the filters still narrow it — ?like:3f2a9c1b #work — and a word after it ranks by that as well: ?like:3f2a9c1b invoice puts the invoices first. Apple Intelligence isn't asked; the list is in order of meaning. If the copy has since been deleted, the line under the search bar says so. A search for copies like one isn't kept with ⌘S, since the copy it names may go. Sealed copies are never offered.

Deleting similar copies

On a copy, press ⌘⌥⌫ — or right-click it and choose Delete Similar… — to delete it along with the copies like it — the ones Find Similar would list. Nothing goes straight away: a window lists each copy that would be deleted, with where and when it was copied, and every box ticked. Untick the ones to keep — click a row (or ⌘-click it), or move with ↑ ↓ and press space — then press ↩ or Delete. esc cancels. To untick a run of rows, untick the first and ⇧-click the last; ⇧-clicking after ticking a row ticks the run instead. ⌘A ticks every row, or unticks them all when they're all ticked.

Pinned copies are never listed, even the one you right-clicked. The deleted copies go to the trash for a day, as one deletion, so ⌘Z in the overlay puts them all back. Like Find Similar, it needs Ask with ? turned on and a licence.

Showing a copy in the history

A search lists what matched, and nothing of what you copied around it. On a row a search found, press ⌘J — or right-click it and choose Show in History — and the search bar empties, the whole history comes back, and that copy is highlighted where it sits, with the copies made just before and after it around it: the network name you copied a moment before the password ?the wifi password found, or the rest of a booking.

⎋ goes back to the search, with the same row highlighted, as long as you haven't typed anything since; a question comes back with its answer, without asking Apple Intelligence again. Once you type, it's a new search and ⎋ closes the overlay as usual.

A pinned copy is shown on the shelf of pins at the top, where it sits.

Tags

A copy can be filed under tags — work, invoice, to-read — to find it by later. A tag is one word, in lowercase; a # typed in front is dropped, so #Work and work are the same tag. Tags are for finding, not for keeping: a tagged copy ages out like any other, and pinning is what keeps one.

Some tags come on their own, from what a copy holds — including copies made before tags existed:

These follow the text: a copy a trigger rewrites into something else loses the tag. They can't be taken off with ⌘⇧T.

A copy tagged color shows the colour itself in a circle at the right of its row.

⌘⇧T tags the highlighted row. A field opens over the tags you already use. Type a few letters to find one — tr finds to-read — and press ↩; a word that isn't a tag yet is offered as New tag at the bottom. Choosing a tag the row already has takes it off (the list says so beside it). ↑/↓ and ⌘1–⌘9 pick from the list, ⇥ finishes a tag so you can type another, and ⎋ leaves without changing anything. To give several tags at once, write them #work,#to-read,#tax — separated by commas, each starting with #. A tag typed without its # is flagged under the field and nothing is given until it is fixed. (Picking a tag from the list needs no #.)

In an empty field, ↑ brings back tags you gave recently, newest first; keep pressing it to go further back, and ↓ to come forward again.

⌘⌥T tags several copies at once. Each row gets a checkbox. Search as usual to narrow the list, then pick rows out with ↩, ⌘1–⌘9 or a click — or ⌘A to pick out every row the search left. Press ⇥, and the search bar holds a command that tags what you picked, waiting for the tag:

@<$2, $5, $9> | tag #

Type the tag — #work, or several as #work,#to-read — and press ↩. While you type, the rows offer the tags you've already used; ⇥ or ⌘1–⌘9 takes one, and ↩ right after the # takes the top one. Once the tag is complete, the rows under the bar are the copies it will tag. To take a tag off them instead, change tag to untag; describe gives them all a description. ⎋ while picking leaves the bar as it was.

⌘F → Tag writes a tag into the search, listed after the kinds, with how many copies carry it, most used first.

Guessed tags

Turn on Guess tags for new copies in Preferences → Copy/Paste and PasteDaemon tags new copies the way you've tagged ones like them. Tag five hotel bookings #trip, and the next booking you copy is tagged #trip too.

• It only guesses tags you use yourself, ones you've given to at least five copies. It never makes up a tag, and never guesses #url or the other tags that come on their own.
• It guesses only when the copies most like the new one agree. Most copies get no guess at all.
• A guessed tag looks different: grey, behind a dashed circle — ◌#trip — where your own tags are in colour.
• Right-click the row to settle it. Keep Guessed #trip makes it an ordinary tag. Not #trip — Take It Off removes it, and that tag won't be guessed for that copy again. In ⌘⇧T, choosing a guessed tag keeps it.
• A guess counts when you search: #trip lists guessed copies as well. is:guessed lists the guesses left to check.

It works the way Find Similar does, from the note the app keeps of what your copies mean. So it needs Ask with ? and a licence, and works on any Mac, with or without Apple Intelligence. Sealed copies and secrets are never looked at, and nothing leaves your Mac. It guesses only for copies made after it's turned on, and only on the Mac where you made the copy. Guesses sync with the copy. A Mac still on an older version doesn't show them.

Only the clipboard history is tagged — a variable already has a name to find it by.

A command or a trigger can tag too, with the tag action:

$1 | tag #work

To tag everything that matches a pattern at once, use tag-all. While you type it, the list below shows what it will tag:

| tag-all "(?i)invoice" #work

untag and untag-all take tags off the same way — | untag-all . #draft retires #draft from everything. Leave the tags off to take off every tag: $1 | untag, | untag-all invoice, or | untag-all --clear-all-tags for your whole history.

Descriptions

A copy can carry a description — a few words saying what it is, like Jira ticket or Staging API key. It shows in italics under the row, and searching finds it.

Give one with the describe action, from a command or from a trigger:

$1 | describe Invoice for Acme

A copy has one description: describing it again replaces it, and describe on its own takes it off.

Some copies describe themselves, once your triggers have run and if nothing else has described them — the ones whose text doesn't contain the words you'd search for:

• a colour by its name: #1e90ff is dodger blue, so blue finds it;
• an emoji or symbol by its Unicode name: 😂 is face with tears of joy, and even an invisible no-break space says what it is;
• a timestamp by its date — a Unix one like 1790000000, or one written out like 2026-09-21T14:13:20Z — is Monday 21 September 2026;
• a UUID, JWT or hash by what sort it is — a JWT also says who issued it and when it expires;
• a cron line in words: 0 9 * * 1-5 is cron: at 09:00 on weekdays;
• a snippet of code by its language, when that's clear: SQL query, Swift code, shell command;
• text in a language you don't read by the language: Japanese text;
• a picture of a QR code or barcode by what the code says: QR code: https://example.com/pay — so searching for the link finds the screenshot. A Wi-Fi code is described by its network, Wi-Fi network “Home”, and never its password;
• any other picture by what's in it: document, receipt.

All of it happens on your Mac; nothing is sent anywhere to be described.

A colour or a UUID made by an action or a command — hex-color, $1 | upper on a colour, uuid — is described the same way, dark orange or UUID (version 4), unless the command gave it a description of its own.

Pins

⌘P pins the highlighted history entry, and unpins one that already is.

The history is a conveyor that runs on time, dropping whatever has outlived its kind's retention. A pin is an entry that has stepped off that belt. It costs one keystroke and asks for nothing else — no name, no dialog, no folder. A pinned entry:

• never expires, whatever its kind is kept for;
• survives Clear History, which is most of what pinning is for, and Clear Older Than as well;
• is not evicted by the image budget, and does not spend it either;
• is still deletable with ⌘⌫, and still forgettable. Both of those are explicit, and explicit wins.

Unpinning puts an entry back on the belt, where its age counts again — so one pinned a month ago, under a retention of a week, goes there and then.

With nothing typed the list is a shelf above a belt: the pins first, oldest pin first, so a new one lands at the end and the ones already there keep the positions your hand has learned. Once something is typed, pins rank like anything else, by what they hold: a pin that floated above better matches would make search worse in exactly the case search exists for. If you'd rather they stayed on top, turn on Keep pins on top while searching in Search settings.

At most six entries may be pinned. Nine rows can be had by number and pins take the top of them, so six leaves three for recent copies. Pinning a seventh is refused rather than silently unpinning the oldest.

Six is deliberately a shelf rather than a library. Variables are the library: named, unlimited, kept just as firmly, and addressable as $name. If something wants a stable handle, it wants a name — a pin's $n still drifts with every copy, because $n is a position.

Only the history is pinned. A variable is already kept until it is deleted, and an action is not something the history holds at all; both say so rather than doing nothing.

Using a row

⌘1–⌘9 acts on that row, ↩ acts on the highlighted one, and clicking a row does the same thing to it:

• a history entry becomes the clipboard contents and moves to the top of the history;
• an action runs against the current clipboard item, and the result becomes the clipboard contents and the newest entry;
• a variable's value becomes the clipboard contents and the newest entry.

With Automatically paste selection on, the result is also pasted back into the app you were in.

↑/↓ move the highlight, as does ⇧⇥. ⌘, opens Preferences.

A click is a press and a release in the same place: the press picks the row out, so the highlight follows your hand, and the release uses it. A hand that travelled is carrying the row somewhere instead. Under a command being written the rows are names the bar is waiting for, and a click fills one in rather than pasting it — the same thing ⌘1–⌘9 does there.

The row menu

Right-click a row — or ⌃-click it — for a menu of what can be done with it. It picks the row out first, so the highlight is on the row the menu is about. Every item is one of the keys that act on a row and shows the shortcut it is bound to, including one you have rebound:

An item that cannot apply to that row is left out rather than greyed: an image has nothing to paste as plain text or edit, an entry that has only held one value has no past values, a copy of files from Finder is files already and offers Show in Finder instead of Save as File, and a secret has no Paste and no file — run it as $!name, or $!name > ~/path for a file.

Open With opens the row in an app of your choosing instead of the one ⌘O uses, which is listed first and marked (default): a link in another browser, text in another editor, a picture in Preview or an image editor, copied files in any app that opens all of them. Text and pictures are opened as a copy, the way ⌘O opens them. It is left out when only one app could open the row, and for a place, which opens in Maps.

Share… opens the Mac's own share sheet beside the row — Messages, Mail, AirDrop, Notes and whatever else you have installed. A link goes as a link, a picture as a picture, copied files as the files and anything else as its text. Once it's shared the overlay closes; back out and it stays open. A secret has no Share…. (Share With is something else: it sends the row to another Mac nearby running PasteDaemon.)

Keep on This Mac stops a copy ever syncing, and takes it off your other Macs if it already had. The row shows a crossed-out cloud, and is:local lists every one. Allow Sync does the opposite for a copy your Sync settings keep here, such as a picture under Text only: it syncs anyway, and the row shows a cloud. Follow Sync Settings undoes that. Each is offered only where it would change something, and none has a shortcut.

There is no menu while a command is being written, since the rows are names for the bar there — except while the bar holds nothing but a name being typed, such as $ or $si: a variable listed then has its usual menu, and what you choose acts on the variable rather than the bar. Its items show no shortcuts there, because under a command those keys do other things — ↩ runs the command, ⌘⌫ deletes what you typed. While rows are picked out, the menu is about them instead — see below.

Picking rows with the mouse

⌘-click a copy to pick it out, and keep ⌘-clicking to pick out more or put one back. ⇧-click picks out every copy from the highlighted row to the one you click, adding to what is already picked. Each row gets a checkbox, as it does for ⌘⌥T, and a search still narrows the list. Once rows are picked out, a plain click on a row or its checkbox picks it out or puts it back too.

Then say what to do with them:

• ⌘⌥T (or ⇥) writes the command that tags them into the bar, waiting for the tag — the same as tagging several copies by keyboard.
• ⌘↩ writes them into the bar as a list, @<$1, $2, $4>. Pictures, files and objects go in as themselves.
• ⌘V pastes them as one.
• Right-click any of them for Tag, Gather into List, Paste as One, Paste as Plain Text, Copy as One, Pin (or Unpin when they all are), Keep on This Mac (or Allow Sync when they all are), Share With (when sharing with nearby Macs is on), Delete and Stop Picking. Right-clicking a row you haven't picked adds it first.

Only copies can be picked out — variables, actions and tags are passed over by a ⇧-click and say so on a ⌘-click. ⎋ stops picking and changes nothing. ⌘⌫ (or Delete in the menu) removes every picked row with no confirmation, as it does for one — into the trash, so one ⌘Z puts them all back.

⇧-click and ⌘-click also work once you have started picking with ⌘⌥T or ⌘↩ from the keyboard; the menu there offers only the ending you started for.

Picking rows from the keyboard

⇧↓ picks out the highlighted copy and the one below it, the way a list in Finder or Mail grows its selection, and each ⇧↓ after that picks out the next. ⇧↑ does the same going up. It stops at either end of the list rather than going round, and passes over rows that aren't copies. Plain ↑ and ↓ still only move the highlight, so you can skip a row and carry on picking below it.

A picking started this way is open to every ending, as one started with the mouse is. With a command in the bar, ⇧↓ and ⇧↑ are the text field's.

Pasting several rows as one

With rows picked out — by ⌘-click, ⇧-click, ⇧↓ or ⌘↩ — ⌘V pastes them as one, in the order you picked them, with a separator between them. Each goes in as it was copied:

It goes on the clipboard in several shapes, and the app you paste into takes the richest it can read. In Notes, Mail, Pages or TextEdit you get the text, the picture and more text. In Terminal or a code editor you get the text alone, and a picture is left out along with the separator beside it.

The separator is a newline unless you choose another in Preferences → Copy/Paste → Pasting: a blank line, a space, a comma, a tab, or text of your own.

The result is kept at the top of the history as one entry, so ⌘V pastes it again in the next app and you can find it later. A large one — screenshots run to megabytes — keeps its pictures beside the history rather than losing them.

• ⌘⇧V pastes their text alone, with no formatting and no pictures.
• ⌘C puts them on the clipboard as one without pasting.

If a sealed row is among them, Touch ID opens it, once for them all, and the paste is their text alone and isn't kept: keeping it would put the secret in an ordinary row.

To choose a separator for one paste, press ⇥ instead and add a join to the list in the bar: @<$2, $5> | join " / ".

How it looks

The overlay comes in four themes, chosen in Preferences → Appearance. They cover the overlay, the small HUD that reports what an action did, and the tutorial card; the preferences window itself keeps the standard macOS look.

The themes are listed down the left of that pane, and the one you click is drawn on the right so you can see it before you commit to it. Clicking does not switch to it — Use This Theme does, and a tick in the list shows which one you are actually using.

• Automatic — Paper when your Mac is set to light, Graphite when it is set to dark. This is what you get unless you pick something else, and it means the panel is never the wrong way round for the screen it is on.
• Paper — light and warm, and still see-through. It sets everything a point larger and gives each row a little more room, which is easier to read and fits about four fewer rows at a time.
• Graphite — dark and solid, with a copper highlight. Nothing of your desktop shows through it.
• Classic — the overlay as it looked before themes: the system HUD, in whatever accent colour you have set in System Settings.

Every theme draws the same panel with the same rows and the same keys. What changes is the colour, the highlight on the chosen row and the size of the text. A theme you pick is used the next time the overlay opens.

Making one of your own

The four above cannot be edited. To change one, select it and press + under the list — or Duplicate, on the right: you get a theme of your own, named after the one you copied, that nothing in a future version will overwrite. It appears under Yours, and its settings are on the right, under the preview:

Colours are written as #RRGGBB, so you can paste one in from wherever you decided it, or pick it with the colour well beside the field. The preview above the settings updates as you go.

Use This Theme switches to it. − under the list removes it, and if it was the one in use the overlay goes back to Automatic.

Where the overlay sits

The overlay opens in the middle of the screen your pointer is on.

Hold ⌘ and drag it anywhere. While ⌘ is down the whole panel is the handle, rows included, so you can take hold of it wherever your hand happens to be. Without ⌘ the rows behave as they always have. A ⌘-click that doesn't move the panel picks out the row instead.

Where you let go is where it opens next time on that display, and every time after that. Each display remembers its own spot: the overlay opens on the screen your pointer is on, where you last left it there, or in the middle of that screen if you have never moved it there. Plugging in or unplugging a monitor does not move it. To put it back in the middle everywhere, use Centre Again in Preferences → General.

A spot that would now hang off an edge is nudged back on screen.

Keeping it up

The overlay closes as soon as anything else takes the keyboard, the way Spotlight does. Keep the overlay up until it is closed, in Preferences → General, turns that off: it stays where it is while you work beside it, and only ⎋, using a row, or a drag that was taken puts it away.

It floats above your other windows without taking focus from them — clicking back into your document goes on typing there, and clicking the overlay again puts the caret back in the search field.

While it stays up, a paste goes into whatever app you were last in, not the one you were in when it opened. That is what keeping it up is for: the panel open beside a document while you take several things out of it, one after another.

Pasting as plain text

⌘⇧V uses the highlighted row as plain text — the text alone, without the bold, the links, the fonts or the background colour it was copied with.

A copy keeps how it looked, so pasting it normally gives the richest version the place you are pasting into can take. That is what you want nearly always, and exactly wrong when you are pasting a paragraph from a web page into a document that is about to keep the web page's fonts.

It is just this once. The row keeps its formatting, so ↩ on it afterwards pastes the rich version again. To narrow a copy for good, use unfmt.

A file list pastes as its paths and a list as its lines, which is what their text already is. An image has no text in it to paste on its own, and says so.

⌘⇧V is the same chord most Mac apps use for "paste and match style". Like every other chord here it can be rebound in Preferences → Shortcuts.

Pasting as plain text is free, and stays free — it is part of the clipboard manager, not the automation a licence buys.

Copying without pasting

⌘C puts the highlighted row on the clipboard and closes the overlay, without pasting it, even with Automatically paste selection on. Use it when you want the row later, somewhere other than where you were. ⌘V pastes it when you get there. It's also in the row menu, as Copy.

Over a command in the search bar, ⌘C runs it and copies the result instead of pasting it. The command runs exactly as written, without finishing a half-typed name the way ↩ does. To make that permanent for a command or a saved action, end it with nopaste: $1 | tidy | nopaste. Saved in an action, it holds the paste wherever the action runs, from the menu bar and shortcuts too.

Some commands never paste, because what they do is the point: tag, untag and describe ($3 | tag #work files $3 and puts it on the clipboard), a saved action that sends its result to a variable, and one that only tags other rows.

If you have text selected in the search bar, ⌘C copies that instead, as it always has. To put the command on another key, change Copy the highlighted row without pasting it in Preferences → Shortcuts.

Pasting and deleting at once

⌘⇧↩ pastes the highlighted row and deletes it, for something you only need once — a one-time code, a password you are typing in somewhere. It pastes the way ↩ does, then the row goes to the trash for a day, and ⌘Z the next time the overlay is open brings it back. It's also in the row menu, as Paste and Delete.

What was on the clipboard before is put back after the paste, so the deleted row isn't left there for the next ⌘V. If the row was what the clipboard held — the code you just copied — the clipboard is left empty. With Automatically paste selection off, the row is left on the clipboard for you to paste, and deleted from the history all the same.

It works on copies only, not on variables.

The keys that act on a row

All of them can be rebound in Preferences → Shortcuts; the footer of the overlay names whatever they are bound to now rather than what shipped, and can be hidden with Show shortcut hints in General once you no longer need it. Where a chord does nothing — ⌘⌫ inside a pipeline, say — the key means what it otherwise means there, so a binding never takes a line edit away from the search field.

⌘/ (or ⌘?) lists all of these on a page over the list, under the chords they are bound to now, along with the keys that move around the overlay, your own overlay shortcuts and the words the search bar understands. ⎋ or ⌘/ again puts it away; the arrows and space scroll it.

Shift with a plain digit is deliberately not a shortcut: ⇧4 is how $ is typed, and every shifted digit has to reach the search bar so that pipelines can be written by hand.

Looking at one in full

⌘L shows the highlighted row whole, over the list. The list is rows of one line each, which is what makes it readable at a glance and useless for telling two long copies apart.

• Text — a clipboard item or a variable — is shown in full, monospaced, in something that scrolls and can be selected out of. The arrows, ⇞/⇟, ⌘↑/⌘↓ and space all scroll it, and ⌘C takes a copy of whatever you have dragged over. A file list is its paths, one to a line. Code in one of the twelve languages lang: knows is coloured: keywords, strings, numbers and comments, as an editor would show them.
• An image is the picture, as large as the panel will take it and never larger than it was copied. To look closer, pinch, press ⌘+ and ⌘−, or double-click a spot to see the picture at its own size there; drag with two fingers to move around it, and ⌘0 or another double-click fits it again. If it has words in it — a screenshot of an invoice, an error message — the words read out of it are shown underneath, to scroll, select and copy with ⌘C. With nothing selected, ⌘C copies all of them and closes the overlay, as it does on a row.
• An action is its help page, all of it.

A copy whose automatic tag says what it is gets a page made for it:

Where the table has no ⌘O, and on a page of plain text or a picture, ⌘O opens a copy of the row as a file in the app that opens that kind, as it does from the list. Editing that file leaves the row as it was.

Only the tags the app gives choose a page: text you tagged #place yourself is still shown as text. A link's preview is fetched from the site, and an address is looked up with Apple, only when you open the page, never while you scroll. Opening a link's page counts as a visit, so a link that only works once — a sign-in or password-reset link — may be spent by looking at it. Secrets are always shown as text and never sent anywhere.

The heading says what is being looked at, and under it the facts a page does not show for itself: when it was copied, the app it was copied in, what produced it, how many characters, words and lines there are, how many values it has held.

Nothing is refused and nothing is changed, which is what makes the page cheap to open. ⎋ goes back to exactly the list that was there, and so does ⌘L again. ↩ uses what you have just read — pastes the item, runs the action — so checking that it is the right one and using it is two keystrokes. The page is a snapshot: something arriving underneath does not rewrite what you are reading, and ↩ uses the row on the page rather than whatever the highlight now stands at.

A look with the pointer

Rest the pointer on a row for a moment and a card comes up beside the overlay with more of it than one line holds: the first lines of the text, the picture and any words read out of it, or the files' names. Under it are the facts the ⌘L page gives, and, for an answer Apple Intelligence chose for a question, why it chose it. That last one is the reason the card is there: a question finds copies by what they mean, and the line a row shows often doesn't say why it was found.

Move to the next row and its card follows. A key, a click or a scroll puts the card away. It goes on the side of the overlay with room for it; with the overlay wide on a small screen there may be no room on either side, and then no card is shown rather than one covering the list.

Secrets and sealed copies have no card, and a link's card is the link as text — the page is fetched only by ⌘L. Turn cards off with Preview a row when the pointer rests on it in General settings.

Editing one

⌘E opens the highlighted row in an editor: ↩ makes a new line, ⌘↩ saves, and ⎋ leaves. It works while you're typing a name in a command, too — type $, pick a variable with ↑ and ↓, and ⌘E edits it; saving brings you back to the command where you left it. A list variable stays a list: each line you save is one item. If you have changed anything, the first ⎋ only says so, and a second one throws the changes away. If the overlay closes some other way while you are editing — you click another window, or press the shortcut that opens it — your changes are kept, and the editor is there with them the next time the overlay opens. That draft is dropped if the row was changed or deleted in the meantime.

If the row is formatted — bold, links, colours, as most copies from a web page or a document are — ⌘E opens it in the editor for formatted text instead, a window with fonts, colours, lists, tables, links and pictures, so the formatting isn't lost. Save there with ⌘S; on the newest row the edit goes on the clipboard too, formatted. Saving, or ⎋, closes it and brings the overlay back, on the same search with the row highlighted. To format a plain row, press Format at the top of the plain editor, or ⌘⇧E: what you've typed so far goes with it.

Writing a new item

⌘N opens the editor empty. ⌘↩ puts what you wrote at the top of the history and on the clipboard, as if you had copied it — for a note, an address you were read over the phone, anything you want to paste later that isn't anywhere to copy from. Format (⌘⇧E) writes it with fonts, links and pictures instead. In the search bar, "text" > $1 does the same, and > $2 puts it in lower down — see Pipelines.

Past values

⌃↩, or ⌃1–⌃9, opens the past values of that row's entry, newest first, each with when it was set and what set it — the action or trigger that produced it, the app it was copied in, or as entered for one you typed. All of them are listed and the list scrolls.

It works on a command that only names something, too: type $logo (or @names, or $3) and press ⌃↩ to see that entry's past values. A secret's past values ask for Touch ID or your password first, and are shown opened.

⌘1–⌘9 or ↩ takes one. For a copy, it goes on the clipboard. For a variable, it becomes that variable's current value again, and nothing is pasted: run the variable when you want it. The restore is itself recorded, so it can be undone. A picture comes back as the picture, a list as a list, and a secret sealed. ⎋ returns to the item list.

Actions have no history of their own, and an entry that has only ever held one value says so rather than opening an empty list.

⌘D on a value in the list shows what changed between it and the one before it.

What changed

⌘D shows two texts as one, word by word: what was taken out is struck through on red, and what was written in its place is on green. Where it was pressed decides what is compared:

• Over a row, its value now against the value before it — what a trigger, an action or an edit did to it. A row that has only held one value says so.
• In a row's past values, the highlighted value against the one before it.
• Over two rows picked out with ⇧↓ (or ⌘-click), one against the other. The one whose value is older is the "before", whichever order you picked them in. This is how to see what proofread or rewrite changed: they run after ↩, and their result becomes a row of its own beside the copy they read.
• Over a command in the search bar, its result against what it starts from, before you press ↩. The line under the result says ⌘D what changed when there is something to show. A command that waits for ↩ — the AI filters, a script that does not preview — has no result yet to compare.

The heading says where each side came from and how many changes there are, with the words added and taken out. Long stretches with nothing changed in them are folded to a line that says how long they were, so a one-word fix in a long document is not a page to hunt through. ⇥ and ⇧⇥ jump to the next and the previous change; the arrows, space and ⌘C read and copy the page as they do on ⌘L's. When the page shows a value against the one before it, ↑ and ↓ move to the newer or older pair instead, so you can read a row's whole past one change at a time; ⇞, ⇟ and space still scroll. ⎋ or ⌘D goes back to where you were — in the past values, with the value you ended on highlighted.

Only text is compared. A picture, an app's own data and a secret are refused, with the reason in the HUD — a secret's values side by side would be on the screen in the clear.

Storing, gathering and inserting

⇧↩ stores a row in a variable by writing the command that does it into the search bar, waiting on the name: $2 > $ for a clipboard item, $name > $ for a variable, $1 | keyword > $ for an action. Type a name, press ↩, and it is stored. The rows underneath offer the variables that already exist, and ⇥ or ⌘1–⌘9 fills one in — and so does ↩, while the name is still empty: on the $ the redirect just wrote, ↩ takes the highlighted variable and a second ↩ stores the value in it. Once anything has been typed after the $, ↩ runs the command as written instead, because at a destination a name that matches nothing is the ordinary case rather than a half-typed one.

The bar says the same thing a field asking for a name would, in the language the rest of the app is written in: whoever presses ⇧↩ once has been shown how a command redirects, and can go on to type the rest of one around it — $2 | trim > $tidy.

Any row can be stored, and it is kept as it was copied: a screenshot as the picture, a formatted line with its formatting, files as files. Pasting the variable puts it back that way — see Variables → Pictures, formatting and files.

⌘↩ gathers rows into a list. It picks rows out the way ⌘⌥T does, starting with the one you pressed it on: ↩ or ⌘1–⌘9 picks out the highlighted row (or puts it back), typing narrows the list, and ⌘A takes every row the search left. A picture, a file list or an object goes in as itself, so the list pastes it as it was copied.

Press ⇥ — or ⌘↩ again — to go back to the bar with the list written in, in the order you picked:

@<$2, $5, $9>

From there ↩ puts the list on the clipboard, dealt out an item per paste — a picture as the picture, files as the files, formatted text as it was copied; | filter works on it, and > @name keeps it under a name. ⌘↩ goes back to picking, and what you pick is added to the end. ⎋ while picking leaves the bar as it was.

⌥↩, or ⌥1–⌥9, writes a row's shorthand into the search bar — $name for a variable, @name for a list, %name for a hash, $n for a clipboard item, and for an action its keyword as the next filter. This is how a pipeline gets built without typing references by hand. Mid-reference it fills in the one being typed rather than starting a new step.

⌘I, while writing a command, opens the overlay inside it. The command is put aside — shown in a strip at the top, so you can see what you're choosing for — and you have the whole overlay again: search, ⌘F for tags and dates, ? questions and saved searches, variables, ⌘L to look at something. Using something writes it into the command where the caret was, instead of pasting it, and puts you back in the command just after it:

• a copy goes in as its position, $2 or $14; a variable as $name, a list as @name, a hash as %name;
• an action goes in as what it makes of the newest copy, $($1 | upper);
• a command you type there goes in on ↩ as $( … ) — so $4 | jq .name becomes $($4 | jq .name), and runs as a step of the outer command. It doesn't run on its own first, so the $1, $2 already in your command still mean the copies they did.

A $ you had already typed is finished rather than doubled. ⌘I in a command written inside goes another level in. ⎋ goes back to the command as it was. Pasting from inside — ⌘⇧V, ⌘C on a row and the like — is refused, since it would close the overlay on the command you're writing.

⌘I works in Preferences too, in the fields of an action, a trigger, an abbreviation or one of your own shortcuts: the overlay opens inside the field, and what you pick is written in where its caret was. What goes in depends on the field:

• A pipeline — an action's, a trigger's, or a pipeline abbreviation's — runs later, when $2 would be some other copy, so a copy goes in as its text in quotes: "https://acme.io/". A variable still goes in as $name, and a command you type as $( … ).
• Any other field — a pattern, a replacement, a script, text to type — gets the text itself: a copy's text, a variable's value, and a command you type is run and its result written in.

A secret, or a copy you sealed, is never written into a field — settings are kept in plain text. ⎋ puts you back in the field as it was, and ⌘Z there undoes what was written.

Deleting

⌘⌫ deletes the highlighted row, whole — past values and all, since what something used to hold is no more wanted than what it holds. There is no confirmation; the HUD names what went, and a copy waits in the trash for a day in case you didn't mean it.

It deletes values, which is both kinds of them: a history entry, or a variable. Deleting a variable is said louder than deleting an entry — an entry would have fallen off the end of the history sooner or later, and a variable never would.

An action is the one row it will not delete, and says where it is deleted instead: actions are configuration rather than content, and the shipped ones cannot be deleted at all.

The overlay stays up, and the list rebuilds under a highlight that does not move, so ⌘⌫ twice deletes two and the next row slides up under the cursor each time. A pin does not survive it. ⌘⌫ does not act while the bar holds a pipeline: there the caret is in text being written, and ⌘⌫ is the line edit it has always been.

The trash

A copy or a variable you delete — with ⌘⌫, by deleting rows you picked out, with the minus button in the Variables pane, or over the API — is kept for a day and then gone for good.

• ⌘Z puts back what you deleted last, where it was in the history, with its pin, tags and past values — a variable back among the variables. Rows deleted together come back together, and pressing it again goes back one more deletion. If you've typed in the search bar since, ⌘Z undoes the typing first, as it would in any text field.
• ⌘⇧⌫ shows the trash, most recently deleted first — or type trash in the search bar and press ↩ on the Trash row. Type to search what's in it, or a variable's name. ↩ or ⌘1–⌘9 puts a row back, ⌘⌫ deletes it for good, and ⎋ goes back to the list.

A sealed copy or a secret goes to the trash too and stays encrypted there — it shows as ••••••••, isn't found by searching, and comes back sealed.

If you've made another variable with the same name since deleting one, it can't come back — the HUD says which name is taken, and it stays in the trash. Rename or delete the new one, then put the old one back.

What the app drops on its own — copies past your retention, a forget run by a trigger or by hand — is never kept.

Clear History, including clearing on quit, empties the trash of copies; deleted variables stay. The trash is kept on this Mac only: deleting a copy still deletes it on your other Macs, and putting it back brings it back there as well. A copy you've copied again since you deleted it is already in the history, so putting it back leaves it where it is.

Saving one as a file

⌘⇧S saves the highlighted row as a file, in the save folder chosen in Preferences → General — your Desktop unless you choose another. The overlay stays up, the way it does for a pin, and the HUD names the file.

⌘⌥V pastes it as a file instead of as text: into a Finder window, as an attachment in a mail message or a chat, or into a web page's upload box. The file is put on the clipboard, pasted, and the clipboard is put back as it was, so the next ⌘V still gives what you copied last. With Automatically paste selection off, the file stays on the clipboard for you to paste.

Both are in the row menu, and both make the same file:

A file already there is never written over: the new one is numbered beside it, notes 2.txt, as Finder numbers a second copy. A copy of files from Finder is files already, so ⌘R shows them in Finder instead. A secret's row holds nothing until the vault reads it, so it offers neither — write one with $!name > ~/path, which asks for Touch ID. A copy that is only another app's own data has nothing to save either.

A file made for ⌘⌥V is written to a folder in the app's caches, and cleared out after a day — long after the app it was pasted into has read it.

To write a result rather than a row, end a command with a path: $1 | json > ~/Desktop/data.json.

Dragging one out

A row can be picked up and carried into whatever window you let go over. It is the same delivery ↩ makes, by the other hand: pasting puts a copy where the caret is, and dragging puts it where the cursor is — which is how something lands in a place a caret cannot be, like a mail window's attachments or a folder in Finder.

What goes over is exactly what a paste would put on the clipboard. Text goes dressed in the shapes it was copied in, richest first, and a row that is one address and nothing else is offered as an address as well, so dropping a copied link on a browser opens a page. Text is a file as well: let go over a Finder window or the Desktop, it becomes the file Save as File would make — Shopping list.txt, config.json — where macOS would otherwise make a .textClipping. A window that takes text takes the text, as before. A link dropped on Finder is left to make the .webloc it always made. A file list goes as the files, one dragged item each, always as a copy. An image goes as its bytes, with TIFF beside them, and as the file it is kept in for windows that attach things.

A variable is dragged like anything else; a list goes as its text, the items one to a line, and a hash as its key: value lines. An action cannot be dragged — the row simply does not lift, which is the whole message and arrives while your hand is still on it.

A drag that is taken puts the overlay away. One that comes to nothing leaves the panel exactly as it was, so the drop can be tried again without going back for the row.

A press without a drag uses the row, the way ↩ on it would.

Dropping something in

Let go of text, a picture or files anywhere over the overlay and they're kept in the history as the newest copy — the whole panel takes the drop, and a dashed border shows while you're holding something over it. A dropped PDF or text file has its words read and a dropped picture is read and looked at, just as if you'd copied them, so ?the lease can find it right away.

A drop is kept the way copying the same thing would keep it: files from Finder become one entry of their paths, and a screenshot's floating thumbnail becomes the picture. It's kept even while recording is paused, but not from an excluded app, and no trigger runs — what's on the clipboard stays there. The overlay stays up afterwards, so you can drop more.

The click that starts a drag in another window would normally close the overlay, so either turn on Keep the overlay up until it is closed in General, or start dragging first and press the overlay's shortcut while you're still holding it.

The menu bar icon

The icon's menu opens the overlay, pauses or resumes recording, lists the 9 most recent items (⌘1–⌘9), lists your variables by name under Variables to paste one without opening the overlay, offers every enabled action for manual application in submenus mirroring their folders, clears the history — all of it, or under Clear Recent just the last 5 minutes, 15 minutes, hour or 24 hours — and opens Preferences, Tip of the Day, the update check and Quit.

A recent item that is an image carries a thumbnail, and while the newest item is an image the actions submenu says so instead of listing actions that could not run. A variable is pasted from the menu the way ↩ pastes it in the overlay — a picture as the picture, a list one item per paste — and hovering one shows what it holds. Secrets are left out of the menu, names and all; $! in the search bar is still the way to one. Where an action carries a shortcut bound everywhere, it is shown as a badge beside it.

Tip of the day

Once a day, the first time you open the overlay, a line under the list shows something PasteDaemon can do — a way to search, a key worth knowing, a filter to try — written with your own shortcuts. Next Tip shows another, and × puts it away. It's gone the next time you open the overlay; Tip of the Day in the menu bar brings the last one back. Turn tips off with Show a tip of the day in General.

Messages

Results, warnings and errors appear in a brief HUD near the bottom of the screen rather than in a dialog, so that triggers never interrupt typing. The three are told apart by colour — plain, orange, red — and a warning is held a little longer, having something to read rather than only to notice.

A message that does not fit on one line wraps onto the next, up to four, and a message that reaches the fourth ends in an ellipsis. How long it stays is worked out from how much there is to read, about four words a second, never shorter than a message used to get and never longer than six seconds.

The daemon's face sits above every message, with the rule or action that fired written underneath it. The HUD is the only place PasteDaemon ever appears unasked — it has no Dock icon and no window of its own — so JSON copied fired over the top of another app would otherwise be a sentence from nowhere. The logo answers which program just rewrote your clipboard before the words are read.