Commands

中文

Start a sentence with @, pick a command, write, and press ⏎: the command runs on what you wrote. Without @, your keys go to the app as usual. With text selected, a command works on the selection instead (see On the selected text). Once AI results are up, what you type is a follow-up and ⇧⏎ sends it: the next question after @question (see Conversations), or a change such as "shorter" or "in Japanese" after @improve (see Refining the results). ⏎ always inserts the selected result.

Command	What it does	Goes to
@improve	Polishes what you wrote, plus rewrites in the styles you picked	Your AI provider
@translate	Translates into the languages you added, a line each	Your AI provider
@question	Answers a question, then follow-up questions as a conversation; the answers can be inserted or copied	Your AI provider
@agent	Hands a task to the coding agent you pick: Claude Code (in the background by default), Gemini CLI, Kiro CLI or your own command. It was @claude up to 0.6.3	That agent on your Mac
@tasks	Lists the background Claude Code tasks	This Mac
@settings	Opens the settings window	This Mac
@config	Changes settings as you describe them, showing each change first	Apple Intelligence on this Mac, else your AI provider
@doctor	Checks the setup on this Mac and fixes what it safely can	This Mac (@doctor <question>: Apple Intelligence, else your AI provider)
@open	Finds files, folders and apps as you type, or opens a web address	This Mac
@note	Saves the text to Notes	Notes on this Mac
@reminder	Adds a reminder, reading the time you wrote	Reminders on this Mac
@calculate	Arithmetic	This Mac
@py, @js	Runs a line of Python or JavaScript	This Mac
@imessage	Sends an iMessage	Messages on this Mac
@reportissue	Reports a problem: GitHub's new-issue page with your title and the details that help	Your browser (you submit it)

The command list

Typing @ at the start of a sentence opens the command list: the ones you used most lately first, 5 at a time, scrolled with ↑↓, the wheel or the trackpad.

• Type letters to find one: a name typed in full first (@rep lists your own @rep before @reportissue and @reply), then names starting with them, then names containing them.
• ⏎, Tab, Space or a digit 1–5 picks one of the rows shown. The text field then shows the command (improve › ); write after it. 0 and 6–9 go in as typed.
• If the letters match no command (@john), the @ is inserted as usual, so @-mentioning people in chat apps still works.
• ← →, or a key that can't be part of a command's name (., :, /), closes the list and leaves what you typed (@, @im) as it is. In a text view the key then does what it always does (→ moves the caret); in a terminal ← → only close the list.
• Holding right ⌥ in the list picks the command first and puts what you say after it.

@ typed right after a letter, a digit, ., _ or - is just text: bob@example.com, ssh user@host and git@github.com:you/extensions.git type as usual, with no command list, in every app, terminals included. After a space, at the start of a line or after Chinese (谢谢@张三) it opens the list as before. What counts is the character you typed into the field just before: after text the input method inserted (a result, a command inserted as typed with ⇧⏎), an arrow key, ⌫, ⏎, a click or another field, @ opens the list. In a field that reports its text, that character must also be right before the caret, with nothing selected.

Script extensions

Your own @ commands as programs: a script in any language with @allinoneime. lines in its comments, a bundle (a folder with extension.json), or a Raycast Script Command as it is. They're read from ~/.config/allinoneime/extensions, folders added under Settings → Custom Commands → Script Extensions, and folders Spotlight finds holding Raycast scripts. From a folder Spotlight found, only its Raycast Script Commands are taken (not its @allinoneime. scripts or bundles: it may be a second checkout or a backup); add the folder to use all of it. A script or bundle that is byte for byte the same as one read before it is skipped quietly ("Skipped N identical copies" in the settings). An added folder that is itself a bundle (it has an extension.json) loads as that bundle. A bundle can also be installed from a Git repository: see Extension sources. The full protocol: docs/extensions.md; examples: Examples/extensions.

• The name is the file name's letters and digits from the first letter, lowercased (base64.py → @base64), or its name key. Names clash in this order: built-in, plugin, custom command, bundle, single script, Raycast script; a bundle command may fall back to its alias. From 0.6.4, agent, config and doctor are built-in names: a custom command, plugin or extension with one of them is hidden (Settings → Custom Commands marks a custom command "Same name as a built-in command: rename it to use it").
• The command list shows its title and group, its icon (emoji, SF Symbol or image), and its status line if it has one. Typing finds names, then words of titles and keywords. A digit right after letters continues a name when one does (@base6).
• Arguments: the text after the command; with two or three, commas (, or ，) split it and the last takes the rest. A missing required one shows "Needs: …"; a dropdown takes a choice's title or value.
• input none: Tab or Space completes the name; the action key runs it.

output	What you get
insert	1: all of it; 2–9: each line. ⏎, Space or a digit inserts, ⌘C copies
show	Lines shown as printed; nothing inserted; ⌘C copies all, ⏎ closes. Leave the field and it goes on in the background
list	Alfred Script Filter JSON, run again as you type (after queryDelay, 150 ms): ↑↓ pick (rows aren't numbered while typing: digits are text), the action key does the row's action (insert, open, copy, run a second step), Tab autocompletes, ⌘C copies text.copy. open takes http(s) addresses and files or folders that exist (file://, /…, ~/…), nothing opening would run (executables, scripts like .sh .py .command), and no other schemes
silent	Its last line near the cursor

• background true: it starts and the field is free; the menu bar panel lists it under "Background Commands"; a notification shows its summary and detail when it's done; clicking opens what it printed. Four at most, one command not twice. Running extensions stop when the input method quits.
• Folders, scripts and bundles may be symbolic links.
• confirm true: "Run X? ⏎ again". A non-zero exit shows its last line; ⏎ retries; Esc stops a run.
• Nothing runs during secure input.

Settings → Custom Commands lists them; see Settings and Configuration.

Extension sources

A bundle can come from a Git repository, yours or your team's, and stay up to date from there. Settings → Custom Commands → Extension Sources → "Add from Link…" takes the repository's address: git@github.com:you/extensions.git, ssh://…, https://…, or file://… for a repository on this Mac. Optionally: a branch, the bundle's folder in the repository (found by its extension.json when there's one, picked from a list when there are several), and a tag or commit to pin it to. http:// isn't taken, nor an https:// address with a user name, password or token in it: git's credential helper keeps those.

• Your own git. It clones with /usr/bin/git, as you, with your login shell's PATH and SSH agent: your keys, ~/.ssh/config, credential helpers and your own ssh command sign in, so a private repository works as it does in Terminal. The app never asks for or keeps a password. git never waits for an answer (no terminal, no prompts, 60 s a call, hooks off), so an unknown host key or a password prompt fails at once. Without Xcode's Command Line Tools, it says to run xcode-select --install.
• Review first. The clone goes into a hidden staging folder under ~/Library/Application Support/AllInOneIME/Sources/. Before anything loads you see the bundle (title, name, version, author), each command (name, title, description, what it outputs) and the program it runs, its preferences, the address and the commit, under "This source isn't signed: it will run programs from" and the address. Only Enable puts it in place and adds it to the extensions; Cancel deletes the staged clone.
• Only reviewed code loads. A source folder in the load list that wasn't reviewed on this Mac (in a config copied from another Mac) isn't loaded. Each source's row says what it loads ("Loaded: @standup @tickets", or "Nothing loaded: …").
• Updates are yours to apply. About 30 s after the input method starts, then once a day, a source is fetched to see what's new; "Check Now" in its ⋯ menu does it at any time. The row shows "N updates" with the new commits (subject, author, date), the page gets a badge in the sidebar, and the menu bar panel says "Extension sources: N updates" (a click opens the page). Nothing changes until you click Update, which only fast-forwards and runs no hooks. After a force push (or more than 100 new commits) Update is refused: Re-clone… shows the review of the new history, and only Enable puts it in place; the reviewed version keeps working meanwhile.
• Pins. The ⋯ menu has Pin to This Commit, Pin to… (a tag or commit) and Unpin. A pinned source isn't checked; Unpin goes back to the branch's newest commit. "Check for Updates Automatically" in the same menu turns the daily check off for one source (autoCheck).
• Errors show git's own last lines (such as "Permission denied (publickey)."), then "This uses your own git and SSH setup; check that git ls-remote <url> works in Terminal", then your own reminder if you set one (authHint in the config, such as "Sign in to your network first, then click Check Now").
• Remove… moves the clone to the Trash and takes the source out of the config; the bundle's preferences (and its passwords in the keychain) are kept for next time.
• From a terminal, with ~/Library/Input Methods/AllInOneIME.app/Contents/MacOS/AllInOneIME: --add-source <url> [--path P] [--branch B] [--pin REF] clones, prints the review and enables it (running it is the consent; it's also how a force-pushed source is reviewed again), --update-sources checks every reviewed source that isn't pinned and fast-forwards it, and --list-extensions lists the loaded commands and what was left out. A running input method picks the change up by itself.

A source has no signature: it runs what its repository holds, as you. Add only repositories you trust. The repository layout and the config keys are in docs/extensions.md.

Keys

Key	What it does
⏎	Runs the command
Space, ⏎ / digits	Once the results are up: insert the highlighted / numbered one; 0 is the original. ⏎ inserts even with a follow-up half typed (it's dropped)
⌘C	Copies the highlighted result (for @open, the path); the candidate panel stays open
⌃V	In a command: appends the clipboard text instead of pasting it into the app; several lines become one, up to 2000 characters (@note keeps the line breaks and takes up to 20000). Works in any app
⌘V	Like ⌃V, but some apps handle ⌘V themselves (terminals and Notes) and paste as usual; use ⌃V there
⇧⏎	With a follow-up typed after AI results: sends it (the next question of an @question conversation, or a refine). While a command is typed, or on AI results with nothing typed: inserts what you wrote as typed, without running it. On @config and @doctor results with nothing typed: does nothing
Esc, ⌫	Back to the sentence to keep editing. After a refine: back to the results before it. In an @question conversation, Esc clears the typed question, then goes back one round
Letters, once AI results are up	A follow-up: after @question the next question (see Conversations), after @improve or a prompt command an instruction such as shorter (see Refining the results); ⇧⏎ sends it. An action key other than ⏎ (⌥Space, say) sends it too. After @translate, letters continue the sentence, and ⏎ translates it again
⌘⏎, ⌘1–⌘9	In an @question conversation: shows where to continue it; ⌘1, ⌘2 … pick one (see Continuing elsewhere)
⌘R	On a saved @question answer: asks it again for a fresh answer (see Recent questions)
Click a row	In the candidate panel: picks it, as its digit would (a word, a command in the list, a result, an @open file, a recipient, an extension's row); the row under the pointer is highlighted. The text field keeps the focus
← → / ↑↓	Picking pinyin or Hindi words, with the candidates side by side (the default): choose a candidate / turn the page (- = turn it too). With "Candidate layout" set to Vertical: ↑↓ choose
Hold right ⌥	Talk, release to stop; see Voice Input
Tap Shift	The next input language, in their order (Settings → Input)

On an error (a timeout, say): Space retries, 0 inserts the original, Esc goes back.

@improve

Example: @i ⏎, type this is a blocker bug your team need fix it asap, ⏎.

• 0: the original.
• 1–3: three polished versions in the language you wrote; 1 is the most idiomatic and is highlighted.
• 4 on: the rewrite styles you picked (Polish, Concise and Formal by default), also in the language you wrote; see Rewrite Styles and Jargon.

The language you wrote is told by its letters: Chinese, Korean (Hangul), Hindi (Devanagari), or for Latin letters English, or French when French is one of your input languages and the words are French.

@improve doesn't translate. With "@improve also translates" on in the settings, it works like @translate @improve. Results appear as they're generated; lines that only change punctuation or repeat another line aren't shown.

@translate

Example: @t ⏎, type running 10 minutes late, start without me, ⏎.

It writes a line in each language you added under "Translate" in the settings, in that order; with only one language, three versions in it. The sentence's own language is skipped. A Korean, Hindi or French sentence is translated into each of them (English and Chinese both, with those two). @translate @improve together (either order) translates and rewrites in one request.

@translate has no refine: once its results are up, typing continues the sentence, and ⏎ translates it again.

@question

Example: @q ⏎, type what is quantum computing, ⏎.

The answer appears as a candidate, in the language of the question: ⏎ or Space inserts it, ⌘C copies it. Answers keep their line breaks (code, steps); in a terminal they go in as a paste, so the shell doesn't run each line.

It can't check live information (the weather, news, prices, scores, anything "today"): asked for it, it says so and gives what general guidance it can, instead of making it up.

Conversations

Once the answer is in, what you type is the next question (pinyin too), shown at the top of the panel as "question 2/5 › …"; ⇧⏎ asks it. The panel grows into the conversation: the earlier rounds dimmed as Q / A rows, the latest answer in full. It grows to about half the screen's height, then scrolls, the latest at the bottom; scrolled up with the wheel or the trackpad, it stays where it is while an answer comes in.

• Every round's answer can be inserted: its digit (1–5), ↑↓ then ⏎, or a click. The latest is selected; ⌘C copies the selected one. ⏎ inserts it even with a question half typed (the question is dropped). 0 no longer inserts the question.
• ⇧⏎ with nothing typed inserts what you typed as is (@question …).
• Esc clears the typed question, then goes back one round (the last question and answer dropped); at the first round it leaves as before.
• Each follow-up is sent as a normal conversation: the questions and answers so far, then the new question. The first question is sent exactly as before. Hiding sensitive information applies to every round.
• Apple Intelligence on this Mac has a small context (about 4K tokens, 8K on macOS 27). When the conversation doesn't fit, the oldest answers are shortened, then the oldest rounds left out (the last question is always sent whole), and the panel says "earlier rounds shortened". Cloud providers get the whole conversation.
• Footer: "⇧⏎ ask · ⏎ insert · 1–5 pick · ⌘C copy · Esc back".
• Up to 5 rounds: questionRounds in config.json, 2–10.

Continuing elsewhere

After the last round, the next question's line becomes "5 rounds in: continue in Claude or another AI", with the choices numbered ⌘1, ⌘2 …; ⌘⏎ shows them at any round (Esc hides them; while an answer is still coming in, ⌘⏎ does nothing). What you type then is the first message there, and only ⌘1, ⌘2 … send it: ⇧⏎ asks nothing more and opens nothing. The text is the conversation in Markdown, "Let's continue this discussion.", and what you typed. A first question about selected text takes that text along, quoted as a block of its own.

Choice	What happens
A coding agent installed on this Mac, by its name	The one @agent hands to comes first (⌘1), then the others (Claude Code, Gemini CLI, Kiro CLI, your own command from Settings → Agent). Each opens an interactive session in Terminal, started as @agent starts it. One that isn't installed isn't shown
Claude, ChatGPT	The web page opens with the conversation filled in; a long one (over 6000 characters) goes on the clipboard instead, to paste
Gemini	Gemini on the web opens, with the conversation on the clipboard to paste
Copy	Puts the conversation on the clipboard, in Markdown (Q: / A:)

Which ones, and in which order (the first is the default): Settings → General → "Continue a conversation in" (questionContinueIn); with more than 5, ⌘6 … ⌘9 pick the rest. Nothing is sent before you pick one, and the conversation goes, as shown, only to that service. Not during secure input or in an app with No AI (Copy still works).

Recent questions

@question with nothing typed after it lists your last 5 questions, newest first, with when they were asked ("3 hours ago"). Typing narrows them down: every word anywhere in the question, in any case (Chinese without spaces too).

• A digit, ↑↓ then ⏎, or a click shows the question's saved answer at once, without going online: Space or ⏎ inserts it, ⌘C copies it, ⌘R asks it again for a fresh answer (it was R up to 0.6.3), Esc goes back to the list.
• A conversation is saved whole, under its first question. Picking it shows all its rounds, and typing goes on with it (any letter, R too, starts the next question); ⌘R asks its latest question again, with the rounds before it.
• With no match, or nothing picked, ⏎ asks what you typed, as before. Once you've typed a filter, digits are text.
• A new answer to the same question, or a conversation that goes on, replaces the saved one. Questions saved by 0.6.3 load as one round.
• They're kept only on this Mac (see Privacy), 5 at most; nothing is kept during secure input, and questions asked on selected text aren't kept.
• Settings → General → "Remember recent questions" (rememberQuestions, on) turns it off and deletes them. Turned off through @config, they're kept, so undoing it puts back exactly what was. "Clear (N)" deletes them.

@agent and @tasks

Example: @agent ⏎, type find out why the tests in ~/code/demo fail, ⏎.

@agent hands the task to the coding agent picked in Settings → Agent, installed on your Mac, with its own sign-in and settings:

Agent	What runs in Terminal
Claude Code (the default)	claude -- <what you typed>; or in the background, see below
Gemini CLI	gemini -i <what you typed>
Kiro CLI	kiro-cli chat -- <what you typed>
Your own command	Its command (agentCommand), what you typed added as its last argument

• Claude Code runs in the background by default: you get a notification when it's done or needs you; click it to open the session in Terminal and go on. Turn off "Runs in the background and notifies me" under Claude Code in Settings → Agent to open Terminal right away instead.
• The other agents open in Terminal with what you typed as their first message. What you typed always reaches the agent whole, however long.
• The agent asks you first, as usual, before changing files or running commands. When the agent picked isn't installed, @agent isn't offered; Settings → Agent shows which ones are.
• @agent was @claude up to 0.6.3. @claude is no longer a command (a command of your own may use the name), and how often you used it carries over to @agent in the command list.
• An @question conversation can go on in each agent installed; see Continuing elsewhere.

@tasks lists Claude Code's background tasks (working, done, waiting for you) with their last replies; ⏎ opens one in Terminal, ⌘C copies the reply. The menu bar panel lists them too.

@open

Example: @o ⏎, type report.

• Lists matching files, folders and apps as you type (Spotlight). Several keywords work, separated by spaces: each must be in the path, at least one in the name; a standard folder's name counts for what's in it (downloads pdf).
• What you opened with @open comes first, then apps and the standard folders, then recently used files. When the names find hardly anything, the files in your home folder are searched by content too, marked "content".
• A web address (github.com, localhost:3000, https://…) opens in the default browser.
• Text starting with ~/ or / is a path: Tab completes it and goes into folders.
• ⏎ opens, ⌘C copies the path. It searches only this Mac.

@note and @reminder

@note books to read: Project Hail Mary ⏎ saves a note in Notes, in a folder named AllInOneIME (made when missing); the first line is the title, and nothing is inserted. After copying some text, ⌃V after @note (or ⌘V outside terminals) brings it in with its line breaks.

@reminder call Bob tomorrow at 3pm ⏎ shows the time it read ("tomorrow 3:00 PM"); ⏎ or Space adds it to Reminders, in a list named AllInOneIME, with an alarm at that time (all day with only a date). Esc goes back to fix it. It reads times like tomorrow at 3pm, in 2 hours, in 3 days at 3pm, on the 15th, this weekend, next month, end of the year.

• A time without am or pm (at 5) is the next one, never between midnight and 6 a.m.; a time already past today is tomorrow.
• Written to repeat (standup every Monday at 9), it's added once.
• Neither goes to the AI. The first time, macOS asks whether AllInOneIME may control Notes or access Reminders.
• If a save fails, the text comes back into the command (or onto the clipboard, if you've moved on), so nothing is lost.

@calculate

@calculate 23*17 → 391, on this Mac: + - * / (also × ÷), ^ or **, parentheses, percent (100+10% is 110), sqrt abs round floor ceil ln log exp sin cos tan min max pow and pi, e. Arithmetic is exact in decimal (0.1+0.2 is 0.3).

@py and @js

@py 2**100, @py import math; math.sqrt(2), @js [1, 2, 3].map(x => x * 2): the value of the last expression, or what it printed, is inserted. @py uses your Mac's python3 (not offered without it); @js uses macOS's JavaScriptCore and can't read files, reach the network or run programs. Code runs in a separate process, stopped after 10 seconds or with Esc. Write it on one line, with ; between statements.

They run only code you typed yourself: in pasted or dictated text, @py, @js and custom run commands stay text, and a notice says so.

@imessage

Type a name, a phone number or an email and pick the recipient (the ones you messaged lately come first), then write the message and press ⏎: the panel shows "Send to Alex (…): …", and ⏎ again sends it. Nothing is typed into the text field. The first time, macOS asks for access to Contacts and for control of Messages.

@reportissue

@reportissue the candidate panel stays up after ⌘Tab ⏎ shows, in the candidate panel, what the issue will hold besides the title: the app and macOS versions, the Mac's architecture (arm64 or x86_64), the interface and input languages, the language packs installed with their versions, the kind of AI provider (and the model, if it's a public one; otherwise "custom"), the action key, whether hiding sensitive information is on, and how many custom commands, plugins, extensions and apps with their own settings you have. Never their names, the text you typed (other than the title), paths, keys, profile names or addresses.

⏎ again (or the action key, or a click on the row) opens GitHub's page for a new issue on MicroZ-LLC/AllInOneIME in your browser, filled in: the title, "What happened / What you expected" to fill in, and those details. Nothing is sent until you click Submit there, with your own GitHub account. Esc goes back to the title. A title isn't needed: you can write it on GitHub. The same page (without a title) opens from "Report an Issue…" in the input menu and in Settings → About.

@config

Example: @config output languages English and French ⏎. Others: @config Chinese in WeChat, more formal in Mail, @config candidates in a column, @config turn off the typos, @config use Claude.

One AI request turns the sentence into setting changes. ⏎ shows them in the candidate panel, a row each, old → new, with the labels Settings uses ("Translation languages: English, Chinese → English, French", "Apps · WeChat · Starts in: Same as everywhere → Chinese"); nothing is changed or typed yet. A part it can't change shows as a ✕ row with the setting and the reason, and the model's note, if it wrote one, shows above the rows. With nothing after @config, the panel shows examples.

• ⏎ (or 1) applies them all; Esc cancels and goes back to the text. Nothing is ever inserted into the text field.
• Typing more starts a refine line ("also German"): ⇧⏎ sends it for a new proposal, and Esc goes back to the one before. ⏎ applies the proposal shown; ⇧⏎ with nothing typed does nothing.
• Once applied, the panel says "Changed N settings": ⌘Z while it's up, or @config undo within 10 minutes, puts back exactly the values those settings had. A setting changed again since is left as it is, and it says so ("Undone; changed since, left as is: …").
• After a switch of provider, Test Connection runs and its result shows under the confirmation; if it fails, it suggests @doctor.
• Only the settings that change are written into config.json; keys this version doesn't know stay as they are.
• When there's nothing to apply, one line shows instead: "Couldn't turn that into a setting", "Those can't be set here: open Settings" or "Already set that way".

What it can change:

Area	Settings
Languages	The translation languages (1–5), the input languages (1–5) and the default one
Writing and typing	The rewrite styles, the candidate layout, typing results out (on or off, the speed, speeding up and slowing down, typos)
General	"Use the selected text", "Remember recent questions", "Check for updates automatically"
Hiding sensitive information	On or off, each kind, words to hide (only added, at most 20 at a time)
Per-app settings	An app's starting language, rewrite styles, typing out and No AI. The app is named as you call it ("WeChat", "Mail") or by bundle ID, and found among your apps; one it can't find, or two that match, is refused
AI provider	Which one, the Bedrock profile (from ~/.aws) and region, a model Settings lists, an OpenAI-compatible base URL (https:// only, for a service Settings offers or an address you typed yourself)

• Never: API keys or anything that looks like one, custom commands, extension folders and sources, plugins, the jargon list, voice input, the action key, the interface language, output tokens and the other Model Settings. Those rows are refused with the reason, and the rest can still be applied. A value that looks like a key is never shown: its row says "a value that looks like a key was refused".
• Checked like Settings: a language that isn't one, more than 5 translation languages or a value out of range is refused row by row. A language whose pack isn't installed says so ("needs the Korean language pack (download it in Settings → Input)").
• Keys: it never switches to a provider that has no key (none in the keychain or your shell). Its row says the key is needed and "you can switch to it there", and applying opens Settings → AI Provider with a small sheet for that key: Save, or Save and Use. A key typed into the sentence is dropped before anything is sent; with nothing else in the sentence, nothing is sent and the key field opens.
• Recent questions: turning off "Remember recent questions" here keeps the saved questions, so undo puts back exactly what was; the row says so. Settings → General → "Clear" deletes them.
• Where it runs: on Apple Intelligence whenever this Mac has it (macOS 26), whatever provider you chose and even before one is set up, held to the allowed settings, with lookups for your apps, AWS profiles and language packs. Otherwise your provider answers. Not in an app with No AI, nor during secure input. What the request holds: see Privacy.

@doctor

@doctor ⏎ checks the setup on this Mac in a second or two ("Testing the connection…" shows while the connection test runs, 12 s at most) and lists the results in the candidate panel: ✗ problems first, then ⚠ warnings, then ✓ what is fine, each with a short fix. The last line sums up ("3 problems, 0 warnings, 9 fine").

Area	What it checks
Input method	Installed, enabled, in your input sources, selectable
AI provider	The API key or the AllInOneIME Cloud sign-in saved (never read or shown); the Bedrock profile's credentials found, their kind and when they expire; Test Connection (only when there's something to test); Apple Intelligence, which @config and @doctor run on
Permissions	Accessibility, the microphone (with voice input on), control of Notes, Terminal and Messages, Reminders; asked of macOS without a prompt
Secure input	Whether it's on, and which app holds it
Language packs	Those of your input languages: missing, damaged or still downloading
config.json	Readable; unknown keys; typing speed and Advanced values out of range; a language twice; more than 5 translation languages
Extensions and plugins	Those that didn't load
Updates	A newer version, the last update error, whether it checks automatically
Logs	Errors from the last week in ~/Library/Logs/AllInOneIME (updates, Rime, plugins, the keychain, AI requests), each as a short fixed phrase

• Fixes. The rows with a fix are numbered: a digit (or a click) shows what it does in @config's preview, and ⏎ applies it. ⏎ on the list applies all the safe ones at once: settings repaired, repeated languages removed from config.json (everything else in the file left as it is), the input method enabled again. Opening a System Settings pane, downloading a language pack, Check for Updates (it opens Settings), the API key field in Settings and copying the aws sso login command are picked one by one. Settings changes undo like @config's (⌘Z, @config undo). Nothing deletes your data or touches a key; an unreadable config.json is never replaced (the row points to the file). ⇧⏎ with nothing typed does nothing on its results.
• @doctor <question> (@doctor why doesn't translate work): after the checks, the AI explains the likely cause in two or three sentences and marks the fixes it suggests; ⏎ still applies only the safe ones (the others by their number). On Apple Intelligence when this Mac has it, which calls the checks it needs as tools; otherwise your provider, and the explanation says "(answered by your AI provider)". Only the check results (paths as ~, no keys, none of your text) and the question are sent.
• In an app with No AI, or during secure input, the checks still run and only the question is refused.
• The checks alone send nothing but Test Connection's sample request, and that only when the provider has a key or credentials to test.

On the selected text

Select some text in any app (a sentence in Notes, a paragraph in Mail), type @improve, @translate, @question or another command that takes text, and press ⏎: the command works on the selection, and the result you pick replaces exactly it.

• The selection stays as it is, still selected, while you type: the command is written in the candidate panel instead of the text field, its first line what you type (pinyin too) and the next "On the selection: “…” (N characters)".
• Text typed after the command is an instruction for @improve and @translate (@translate ja, @improve more formal), answered as one rewrite that keeps the text's paragraphs; after @question it's the question about the selection (@question what does this mean).
• Esc, ⇧⏎, clicking elsewhere or secure input turning on leave the text as it was, with no @improve typed over it; changing the selection meanwhile cancels the command.
• @open, @agent, @tasks, @settings, @reminder, @imessage, @reportissue, terminal commands and script extensions don't use it: they take what you type, and the selection stays as it is.
• Up to 5000 characters; never read during secure input or in a terminal. The selection is read through the text input system, or, where an app doesn't report it there, with the Accessibility permission if AllInOneIME already has it (it never asks for it). The log records only how it was read and its length.
• On by default; turn it off under Settings → General → "Use the selected text" (useSelection) if it misbehaves in an app.

Refining the results

While the results of @improve, a prompt command (your own or a plugin's) or the rewrite of a selection are up, type what to change (shorter, warmer, more formal, add a joke, in Japanese, 用更口语的说法) and press ⇧⏎: the AI gets the original request, the results shown and your instruction, and the new results stream in in their place, in the same panel. ⏎ inserts the selected result instead, also with an instruction half typed (it's dropped). Refine as often as you like; the panel's top line lists the steps ("Refined: shorter · more formal"), and you can pick a row at any time as usual. After @question, what you type is the next question instead (see Conversations).

• Starting: a letter starts the instruction, shown at the top of the panel as "refine › …". With none typed, digits, Space and ⏎ pick as before, 0 the original, and ⇧⏎ inserts what you typed as is. Once it's started, Space, digits and punctuation are part of it; pinyin works, and a tap of Shift switches languages. Up to 200 characters.
• Only once the results are complete: while the first results still stream in, typing continues the sentence, as before.
• ⇧⏎ sends it (so does an action key other than ⏎). On selected text, the row you pick in the end still replaces exactly the selection, untouched until then. Footer: "⇧⏎ refine · ⏎ insert · …".
• Esc clears the instruction, then goes back one step to the results before the last refine, then to the sentence. ⌫ on an empty instruction steps back the same way.
• While a refine runs ("Refining: shorter…"), you can type the next instruction; ⇧⏎ sends it once the results are in. Esc stops the refine and brings back the results before it.
• When it fails (the network, no result, refused during secure input): the results stay as they were, and the instruction is back in the line, ready for ⇧⏎ to try again. The same refine of the same results comes from the cache.
• Not refinable: @translate (typing after its results continues the sentence, and ⏎ translates it again), program output (@py, @js, scripts), @open, @reminder, @imessage, and a sentence with commands inside it.
• Up to 0.6.3, ⏎ sent the instruction; from 0.6.4, ⇧⏎ sends it and ⏎ always inserts.
• In an app with "No AI in this app" (Settings → Apps), nothing is sent. With hiding sensitive information on, the refine uses the same placeholders as the first request.

Commands inside a sentence

Commands that fetch something also work inside another command: @reply the total is @calculate 23*17 dollars, @reply tell her @stock AAPL is up today. The inner ones run first and their output takes their place. Put an argument with spaces in quotes: @question explain @py "sum(x * x for x in range(10))". Not inside @note, @reminder, @agent, terminal commands or code: those get the text as written.

Your own commands and plugins

In the settings, under "Custom @ Commands", click "Add Command…": an AI instruction, a program, a program in Terminal, or a web page, under a name you pick. Plugins are ready-made commands such as @stock AAPL and @xe 100 USD EUR: "Browse Library…" under "Plugins" installs them from the signed plugin library. Details: the README. For commands written as scripts, see Script extensions.

The action key

⏎ by default; under "Action key" in the settings you can pick Tap ⌥, ⌥Space or Space instead. Whatever it is, commands also run on ⏎.