aside

aside is a prompt queue for Claude Code. Queue prompts, ideas and comments while Claude works, without interrupting it, and send them once it finishes or whenever you are ready.

How it works

1. Note it while Claude works

To comment on something, copy it first (Ctrl+C or ⌘+C), from anywhere: VS Code, a terminal, a web page. Then start a message with +, or end one with it. It goes to the queue, not to Claude. No paste needed: aside takes whatever is on your clipboard.

Note

What you type in a hurry is tidied as it is queued: spelling, punctuation, wording. What you copied stays exactly as copied. To keep entries as typed, set tidy to off in /config. The other settings are under Settings.

2. Answer Claude as usual

Your reply goes to Claude. By default the queue just waits, in a line above the prompt. Its list button opens a pane with the queue, the tags in files and the plan, and plan to organize them. Beside it, run plan shows while the plan has steps left, continue while a step waits for you or a run is paused, and stop while a step runs. /aside opens the same pane while Claude works, and /aside g, q, find, log and help show what they have to say there too, with queue to go back.

3. Look at it when ready

Nothing reaches Claude until you say so. /aside shows the queue in a frame, and /aside pop N puts one entry in the prompt box, ready to send.

4. Plan and run

/aside plan has Claude turn the queue into steps, shown in a frame. Anything unclear goes back to the queue with Claude's question. While a step runs, it adds the queue as new steps after the plan's own and leaves those as they are: Claude organizes it once the step ends and the run waits for continue, or with planModel on a model, at once while the run goes on.

/aside run all sends the steps one at a time, each ending with a one-line result, and /aside run sends only the next one. A step that needs you waits for your answer: answer as usual, and Claude's reply to it ends the step and runs the next, unless Claude asks again; continue ends a waiting step without an answer. A step that leaves work going in the background, such as a workflow or an agent, goes on until that work is done, and the line above the prompt says running in the background; continue ends it sooner, and work that never ends by itself, such as a server, ends the step after backgroundWait. After the last step, Claude sums the run up.

Every situation aside handles, with diagrams of how it works, is in docs/use-cases.md.

Install

/plugin marketplace add gravityXX/aside
/plugin install aside@aside

Requires Claude Code 2.1.301 or newer, whose plugin API is still in early access. If /aside is an unknown command, sign in again with /login.

• Terminal on Linux, macOS, Windows and WSL: everything.
• Remote Control from a phone or the web: + entries are queued; the list shows in the terminal.
• Desktop: once its built-in Claude Code reaches 2.1.301; add entries with /aside TEXT.
• Not yet: cloud sessions, Desktop sessions inside WSL, and drawing in VS Code.

Commands

/aside                 show the queue and the plan
/aside plan            have Claude turn the queue into steps, or add them to a running plan
/aside run             run the next step of the plan, or the first entry of the queue
/aside run all         run the plan step by step, or the queue entry by entry
/aside run 3 1         run only those steps, or those entries
/aside continue        end the step that waits for you and go on
/aside stop            stop after the current step
/aside log [N]         the plans run to their end, with what each step did, or plan N

/aside TEXT            queue TEXT, as + would
/aside pop [N]         put the first entry, or entry N, in the prompt box
/aside edit N          rework entry N and queue it again
/aside move N M        move entry N to place M
/aside remove N ...    remove one entry, or several
/aside clear           empty the queue
/aside undo            bring back what the last clear, or an unanswered plan or run, took
/aside find TEXT       look for words in the queue, the tags, the plan and every queue
/aside import FILE     queue the items of a markdown list in FILE, each an entry
/aside scan FILE       read the tags of a file Claude did not write
/aside export [FILE]   save the list as Markdown, to aside.md or FILE
/aside help            list every command

+g TEXT                put an idea on the global list, which belongs to no project
read it later +g       the whole draft, onto the global list
/aside g               show the global list
/aside g here N ...    move ideas N of the global list to the end of this queue
/aside g add N ...     move ideas N of this queue, numbered as /aside shows them, to the global list
/aside g remove N ...  remove from the global list; g edit N, g pop [N] and g move N M as for the queue
/aside g clear         empty the global list; /aside g undo brings back what it took
/aside g import FILE   put the items of a markdown list on the global list

+@work TEXT            put an idea in the queue named work, made by its first idea
read it later +@work   the whole draft, into the queue work
/aside q               show the global list and every named queue, with its first three ideas
/aside q work          show the queue work; the commands of /aside g work on it, as in /aside q work here 1
/aside q work clear    empty it, or with rename X move it all to the queue X, merged with any ideas there
/aside q work local    keep it for this project alone; /aside q work global shares it again

The global list and the named queues wait in every project: the line above the prompt counts them all together, as in 3 in other queues, /aside leaves them out, and plan and run take only this queue, so /aside g here or /aside q work here brings an idea in first. The global list is the queue named global, so +@global is +g. Several sessions can add to them at once. /aside undo does not bring back what left them; a queue's own undo brings back what its last clear took. A named queue can also be this project's alone: /aside q work local keeps it here, where +@work then goes to it and other projects no longer see it, and with the newQueues setting on local a queue is this project's from its first idea.

ls, mv and rm are short for list, move and remove, on a queue too, as in /aside g rm 2. N is a number as /aside shows it, and [N] may be left out. FILE is one word ending in .md. While Claude works, /aside, /aside g, q, find, log and help open in a pane, with queue to go back. Tab completes every command.

Other ways to comment

why is this so slow +?           the whole draft, as a question
+? why did this fail             nothing copied: the last tool output, an error first
+? @docs/report.md:42 why        line 42 of that file
+! @report.md#results shorter    the Results heading
+- #appendix                     a heading in a file Claude wrote this session
<!-- ? why -->                   a tag in a markdown file

In a tag, ! is a change, - a drop and + dig deeper. Tags count in markdown files Claude wrote or edited this session; /aside scan FILE adds any other. In fullscreen mode, lines you select in Claude's reply count as copied.

Settings

Change these in /config:

• afterClaudeAnswers: wait (default), plan or run all. What aside does once Claude answers.
• backgroundWait: 5 min, 15 min (default), 30 min or never. How long a step may go on in the background before aside ends it and the plan goes on, for work that never ends by itself, such as a server a step starts. never leaves it to continue.
• planModel: session (default), sonnet, haiku or opus. Who organizes the queue on /aside plan: Claude in this conversation, knowing the work so far, or one call to that model outside it, which adds nothing to the conversation and runs while Claude works, but sees only the queue.
• newQueues: global (default) or local. Whom a named queue made by its first idea, as in +@work, is for: every project, or the one it was made in.
• order: oldest (default) or newest. Which entry comes first in the list and in a run.
• tidy: on (default) or off. Whether a small model fixes the spelling and wording of what you type, and names a step made of a long entry.

More

Important

The queue stays on your machine, one per project, beside the global list and the named queues for ideas that belong to no project. Nothing reaches Claude's conversation until you run /aside plan or /aside run, or afterClaudeAnswers does. With tidy on, the text you type goes to Haiku to be corrected; what you copied never does. With planModel on a model, /aside plan sends the queue to that model in place of the conversation.

What aside reads, writes, runs and sends

Beyond what the box above says, nothing leaves the plugin: no HTTP call of its own, no socket, no telemetry. It installs nothing and reads no credential, token or environment variable of yours. Your queue and plan live in Claude Code's store for the plugin, and the only file it writes is the one you name in /aside export.

The long version: every file it touches, program it runs and prompt it sends

• Keeps the queue, the plan and what /aside undo brings back, one set per project, and the global list and the named queues, shared by all projects, in Claude Code's store for the plugin (~/.claude/plugins/store/).
• Writes one file, and only when you run /aside export: the path you name. It reads what is already there first and refuses unless that file is an earlier export of its own, so it cannot land on your notes, a settings file, a lockfile or anything else that was not written by /aside export. It writes no build, start-up, settings or instructions file - not CLAUDE.md, not settings.json, not a lockfile, nothing of Claude Code's own - and changes no file in your project.
• Reads <!-- ? --> tags in markdown files Claude wrote or edited this session, or that you /aside scan; for a comment, the clipboard, the lines you selected in Claude's reply, the last tool output and the project's markdown files; the project's git branch.
• Runs three programs, each for one job:
  • a clipboard reader, so that a comment keeps the quote you copied without a paste: powershell.exe -NoProfile -NonInteractive -Command "[Console]::OutputEncoding=[Text.Encoding]::UTF8; Get-Clipboard -Raw" on Windows and WSL, pbpaste on macOS, and wl-paste --no-newline --type text, xclip -selection clipboard -out or xsel --clipboard --output on Linux. The first one that works is kept for the session;
  • git -C <project> rev-parse --abbrev-ref HEAD, to name the branch an entry was queued on;
  • grep -rlizP --include=*.md --include=*.markdown --include=*.mdx --exclude-dir=node_modules -e <words of the quote> <project>, to find the markdown file a copied quote came from. Where that grep is missing, it walks the files through Claude Code instead.
• Puts in the prompt box only what you asked for: /aside pop N fills the box with that entry as you wrote it, and queuing with + empties the box it took the entry from.
• Submits one prompt per step of a plan you ran, and nothing else. /aside run and /aside run all send the step's prompt - the text /aside plan made from your own entries - to Claude in this session, as if you had typed it.
• Sends nothing off your machine by itself. Three things leave the plugin, all through Claude Code: the step's prompt, to Claude in your session; with tidy on, the text you typed, to Haiku, to have its spelling and wording fixed, never what you copied; with planModel set to a model, the queue, to that model, to be organized into steps. There is no other way out: no HTTP call, no socket, no telemetry.

Where it listens. The two tools whose names end in __plan and __wait are this plugin's own, registered at session.start; aside calls into no other plugin.

It listens on	and
session.start	registers the /aside command and this plugin's two tools, and loads this project's queue
prompt.submit	takes a message that starts or ends with + into the queue instead of sending it; otherwise reads your reply as the answer to a step that waits, and a background task's notification as the end of the work a step left running
prompt.change	empties the prompt box once an entry has been queued from it
prompt.autocomplete	completes /aside's subcommands and your queue names
tool.call	keeps the last tool output, so that a comment can quote it; notes work left running by Workflow, Agent, Bash or TaskStop; remembers a markdown file Write or Edit touched, to scan for tags; takes the plan from this plugin's own two tools
turn.start, turn.complete	binds a turn to the step running, and moves the step on when that turn ends
session.end	leaves a step that was running waiting for you, rather than lost
command.run	runs /aside
ui.render	draws the line above the prompt, the pane, the frame around a listing and the plan tool's own output

Contributing

Found a bug or have an idea? Open an issue and say what you did, what you expected and what happened, with your Claude Code version (claude --version) and your system.

To change something yourself, fork the repository, work on a branch and open a pull request. CONTRIBUTING.md shows how to run and test the plugin from your copy, and docs/guidelines.md how the code is laid out, written and reviewed. A pull request needs a passing CI run and the maintainer's review before it is merged.

Support

aside is free, and I put time and effort into it. If it saves you time, star the repository so others can find it, or sponsor its development and more useful skills to come.

Thank you to everyone who reports a problem, suggests an idea or sends a fix. Enjoy your queue.

_{LICENSE · CHANGELOG · CONTRIBUTING · SPONSOR}