Skip to content
Back to search

r3v3rs3

MarketplaceWorks with Claude CodeGitHub

Claude Code plugin: hold what you type while the agent works and it arrives when the turn ends, no interruptions. Run subagents in their own git worktree, pick model and effort, chat with them. All from a side panel, with the mouse.

Safety scan

A static text scan, not a guarantee. Select the badge to see what was scanned and every finding.

Badge for your README
findsafeskills safety rating

Markdown

[![findsafeskills safety rating](/api/listings/petersonsenadevs--cmc/badge.svg)](/listings/petersonsenadevs--cmc)

HTML

<a href="/listings/petersonsenadevs--cmc"><img src="/api/listings/petersonsenadevs--cmc/badge.svg" alt="findsafeskills safety rating" /></a>

Install

Install instructions from the README

As written by the repo's author. findsafeskills has not verified these steps.

This repository is a Claude Code marketplace (`r3v3rs3`) that holds the plugin in `plugins/cmc`. Add the marketplace, then install the plugin from it:

/plugin marketplace add petersonsenadevs/cmc
/plugin install cmc@r3v3rs3

From a terminal: `claude plugin marketplace add petersonsenadevs/cmc` and `claude plugin install cmc@r3v3rs3`. Add `--scope project` to both to enable it for one project only. A local checkout works too: `claude plugin marketplace add /path/to/the/checkout`, or `claude --plugin-dir /path/to/the/checkout/plugins/cmc` to try it without installing.

Update and remove:

claude plugin marketplace update r3v3rs3 && claude plugin update cmc@r3v3rs3   # held messages and settings are kept
claude plugin uninstall cmc@r3v3rs3              # also deletes held messages and settings; add --keep-data to keep them
claude plugin marketplace remove r3v3rs3

What was scanned

The files the safety scan read, as written by the repository's author and shown as plain text. Lines with a finding are marked.

.claude-plugin/marketplace.json · Manifest · 17 lines
  1. {
  2. "name": "r3v3rs3",
  3. "owner": {
  4. "name": "Peterson Sena (r3v3rs3)"
  5. },
  6. "metadata": {
  7. "description": "Claude Code plugins by Peterson Sena (r3v3rs3)."
  8. },
  9. "plugins": [
  10. {
  11. "name": "cmc",
  12. "source": "./plugins/cmc",
  13. "description": "Claude Message Control: a hub to hold what you type while the agent works and deliver it when its turn ends, without interrupting it, and to run subagents in their own git worktree that you can talk to.",
  14. "version": "1.1.1"
  15. }
  16. ]
  17. }
README.md · README · 254 lines
  1. # cmc — Claude Message Control
  2. <picture>
  3. <source media="(prefers-color-scheme: dark)" srcset="plugins/cmc/assets/logo-dark.png">
  4. <img alt="cmc — Claude Message Control, by r3v3rs3" src="plugins/cmc/assets/logo-light.png" width="600">
  5. </picture>
  6. by [r3v3rs3](https://github.com/petersonsenadevs)
  7. [![Version](https://img.shields.io/badge/version-1.1.1-7C5CFF)](CHANGELOG.md)
  8. [![License: MIT](https://img.shields.io/badge/license-MIT-2BB673)](LICENSE)
  9. [![Claude Code](https://img.shields.io/badge/Claude%20Code-%E2%89%A5%202.1.330-555)](https://code.claude.com/docs)
  10. [![Node.js](https://img.shields.io/badge/node-%E2%89%A5%2022.18-339933?logo=node.js&logoColor=white)](https://nodejs.org)
  11. [![TypeScript](https://img.shields.io/badge/TypeScript-no%20build-3178C6?logo=typescript&logoColor=white)](https://www.typescriptlang.org)
  12. [![Platforms](https://img.shields.io/badge/platform-Windows%20%7C%20macOS%20%7C%20Linux-555)](#known-limits)
  13. [![Plugin](https://img.shields.io/badge/Claude%20Code%20plugin-hub-7C5CFF)](#the-cmc-hub)
  14. A Claude Code plugin that puts you in control of the conversation with the agent: **hold** what you type while it works
  15. and it reaches the agent when its turn ends, without interrupting it; change, reorder or delete it before then; and hand
  16. tasks to **subagents** that work in parallel, in their own git worktree, and talk back to you. Everything from one panel
  17. beside the chat, the **cmc hub**, with the mouse or the keyboard.
  18. Version 1.1.1 · MIT license · see [CHANGELOG.md](CHANGELOG.md).
  19. ## Requirements
  20. - Claude Code 2.1.330 or newer (the hub uses Claude Code's plugin engine)
  21. - Node.js 22.18 or newer. The plugin is written in TypeScript and Node runs the `.ts` files directly: there is no
  22. build step and nothing to install besides the plugin folder (no runtime npm dependencies)
  23. ## Install
  24. This repository is a Claude Code marketplace (`r3v3rs3`) that holds the plugin in `plugins/cmc`. Add the marketplace,
  25. then install the plugin from it:
  26. ```
  27. /plugin marketplace add petersonsenadevs/cmc
  28. /plugin install cmc@r3v3rs3
  29. ```
  30. From a terminal: `claude plugin marketplace add petersonsenadevs/cmc` and `claude plugin install cmc@r3v3rs3`. Add
  31. `--scope project` to both to enable it for one project only. A local checkout works too: `claude plugin marketplace add
  32. /path/to/the/checkout`, or `claude --plugin-dir /path/to/the/checkout/plugins/cmc` to try it without installing.
  33. Update and remove:
  34. ```
  35. claude plugin marketplace update r3v3rs3 && claude plugin update cmc@r3v3rs3 # held messages and settings are kept
  36. claude plugin uninstall cmc@r3v3rs3 # also deletes held messages and settings; add --keep-data to keep them
  37. claude plugin marketplace remove r3v3rs3
  38. ```
  39. ## In one minute
  40. 1. While the agent works, type `;; also update the README` and press Enter. The message is **held**: the agent is not
  41. interrupted, and the message reaches it **when its turn ends**.
  42. 2. The **cmc hub** opens beside the chat (or type `/cmc`). There you see what is held and can send it now, edit it,
  43. reorder it, delete it, or hand it to a subagent.
  44. 3. Type `>> review the tests of module X` to start a **subagent** on a task. It works apart, in its own worktree, and
  45. its answer comes back to you; you can keep talking to it from the hub.
  46. ## The cmc hub
  47. `/cmc` opens or closes it; by default it also opens by itself when you hold a message or a subagent starts. It needs a
  48. terminal about 110 columns wide or more; below that, `/held` and the control words still do everything.
  49. ```
  50. ▄▀▀ █▀▄▀█ ▄▀▀ Claude Message Control
  51. ▀▄▄ █ ▀ █ ▀▄▄ by r3v3rs3
  52. ● Agent working · held messages go to it when its turn ends
  53. [ Messages 2 ] [ Subagents 1 ] [ Activity ] [ Settings ] [ Help ]
  54. What you hold for the agent. Click a message for its actions; type below to hold one without ";;".
  55. Messages delivered when the turn ends · ;; holds for the agent · subagents get the whole conversation
  56. ▸ 1 also say kiwi · goes when the turn ends
  57. [ Send now ] [ To subagent ] [ Edit ] [ ↑ ] [ ↓ ] [ Delete ]
  58. 2 review the README for typos · goes when the turn ends
  59. [ Send all ] [ Clear ]
  60. ┌───────────────────────────────────────┐
  61. │ Type a message to hold for the agent │ [ Hold ]
  62. └───────────────────────────────────────┘
  63. v1.1.1 cmc
  64. ```
  65. | View (key) | What is in it |
  66. |---|---|
  67. | **Messages** (`1`) | What you hold. A click on a message shows its actions (keys `s` send, `a` to subagent, `e` edit, `d` delete); edits happen in the row. The box at the bottom holds a message without typing `;;`. |
  68. | **Subagents** (`2`) | A box to start a new subagent task, and every subagent with its state, time, context, model and effort. A click opens its **conversation as a chat** — your messages on the right, its answers on the left, its steps in between — with a box to write to it, **Send result to main** and **Stop**. |
  69. | **Activity** (`3`) | What happened, newest first. The latest two lines also show under the other views. |
  70. | **Settings** (`4`) | The modes below, each with a line on what it does. A change applies at once and is kept. |
  71. | **Help** (`5`) | How cmc works, section by section: holding, sending, subagents and their flags, settings, the hub. |
  72. Bottom right: the version, and **cmc**, a link to this repository.
  73. ### Send now
  74. **Send now** hands a message over at once. With the agent idle it starts a turn with it. While the agent works, the hub
  75. puts the text in your prompt box and you press **Ctrl+Enter** (or Ctrl+X Ctrl+S where the terminal does not pass
  76. Ctrl+Enter): that is Claude Code's own *send now*, which delivers it into the running turn as your message. The message
  77. leaves the queue when you send it; if you clear the box instead, it stays held. (No plugin can press that key for you,
  78. and handing text into a running turn any other way proved unreliable: the model set it aside more than half the time.)
  79. ### Modes (Settings)
  80. | Mode | Values | What it does |
  81. |---|---|---|
  82. | Open the hub | **Automatically** · Only with `/cmc` | Whether the hub opens by itself when you hold a message or a subagent starts. |
  83. | Deliver | **End of turn** · Hold | What you hold while the agent works reaches it when its turn ends, or waits until you send it. |
  84. | Typed `;;` goes to | **Main** · Subagent | A held message waits for the main agent, or starts a new subagent so the main conversation stays clean. |
  85. | Subagent context | **Full** · Summary | A copy of the whole conversation, or a short summary (cheaper, less to go on). |
  86. | Results | **Hold** · Auto | A subagent's answer waits in the hub, or goes to the main agent by itself when a turn ends. |
  87. | Subagent model | **Same as mine** · fable · opus · sonnet · haiku | The model new subagents run with (`--model`). A full model name can be set in the settings file. |
  88. | Effort | **Same as mine** · low · medium · high · xhigh · max | How hard they think (`--effort`): lower is faster and cheaper. |
  89. ## Holding and sending from the chat
  90. | You type | What happens |
  91. |---|---|
  92. | `;; also update the README` | **Held** (one-line notice). While the agent works, it reaches it when its turn ends; while it is idle, it waits for you. |
  93. | `/held` | A menu (Claude Code's own dialog): pick a message, then Send, Edit, Delete or Hand to an agent. |
  94. | `/send` · `/send 2` | Sends everything, or message 2: now if the agent is idle, or into the prompt box for Ctrl+Enter while it works. |
  95. | `/cmc:release` | Every held message is handed over (when the turn ends, if the agent is working). Works everywhere, also headless. |
  96. | `;;end` · `;;now` | Hand messages over when the turn ends, or now if the agent is idle (`;;end 2`, `;;now 1 3` for some). |
  97. Control words are typed right after the prefix, with no space; the plugin answers them itself (the agent never sees
  98. them and they cost no tokens): `;;list`, `;;edit 2 new text`, `;;rm 2`, `;;clear`, `;;move 3 1`, `;;up 2`, `;;down 2`,
  99. `;;top 3`, `;;bottom 1`, `;;help`. With a space after the prefix it is a message: `;; clear the cache` is held,
  100. `;;clear` empties the queue.
  101. When a turn ends with something still held, one line under the transcript says so. The queue survives closing and
  102. resuming the session (`claude --resume <id>`) and compactions; sessions inactive for 30 days are cleaned up.
  103. ## Subagents
  104. | You type | What happens |
  105. |---|---|
  106. | `>> review the tests of module X` | A subagent starts on that task. It forks this conversation, so it knows everything said so far. |
  107. | `>> --pack --model sonnet --effort low task` | With a short summary instead, and its own model and effort (`--model=sonnet` works too). |
  108. | `>> -s -m sonnet -e low task` | The same, short: `-m` model, `-e` effort, `-w` whole conversation, `-s` summary, `-a` its result comes back by itself. Flags go first. |
  109. | `;;dispatch 2` | Hands held message 2 to a subagent instead of the main agent (flags as above). |
  110. | `;;tell 1a2b now list the open tasks` | Writes to subagent `1a2b…`: it reads it after its current step, or its closed session is resumed with it. |
  111. | `;;agents` · `;;log 1a2b` · `;;cancel 1a2b` | Lists the subagents, shows what one did, stops one. |
  112. - **Its own worktree.** In a git repository it works in `.claude/worktrees/cmc-<id>` on the branch `worktree-cmc-<id>`,
  113. so it never touches the files the main agent is working on. When its session closes, a worktree with changes is kept
  114. for you to review and merge; one without changes is removed. Add `.claude/worktrees/` to your `.gitignore`. Outside git
  115. it works in the same folder, and says so.
  116. - **A conversation.** After it answers, its session stays open (`dispatch.keepOpenMinutes`, 10 by default) so you can
  117. write to it; each answer comes back to the hub, labelled as the subagent's report, not as something you typed.
  118. - **Limited permissions.** `acceptEdits`, and only the built-in tools `Read`, `Glob`, `Grep`, `Edit`, `Write` (no shell, no
  119. web), whatever your settings allow; never `bypassPermissions`. Tools from MCP servers are not covered by that limit.
  120. Restricting the tools makes a fork miss the session's prompt cache, so it costs more; `"restrictTools": false` trades
  121. the limit for the lower cost.
  122. - **Your setup runs in it.** Your other plugins and hooks run in the subagent too. If some of them write files into its
  123. worktree (notes, memory), list those paths in `dispatch.ignoreChanges` so they do not count as its work.
  124. ## From another terminal
  125. Run `cmc` in a second terminal **in the folder where the session was started**: `cmc hold <text>`, `cmc list`, `cmc edit`,
  126. `cmc rm`, `cmc move`, `cmc release`, `cmc dispatch [--pack] [--model …] [--effort …] <task>`, `cmc agents`, `cmc tell <id>
  127. <text>`, `cmc log <id>`, `cmc cancel <id>`, `cmc config [init | set <mode> <value>]`, `cmc sessions`. `cmc help` lists
  128. them all.
  129. Installed from the marketplace, the command is in Claude Code's plugin cache, under a folder named after the version:
  130. `node ~/.claude/plugins/cache/r3v3rs3/cmc/1.1.1/bin/cmc.ts list` (an alias helps, since the path changes with each
  131. update). From a checkout: `node /path/to/the/checkout/plugins/cmc/bin/cmc.ts`, or `npm link` in the repository.
  132. ## Settings file
  133. Everything works without it. `cmc config init` writes `config.json` in the plugin data directory with every setting at
  134. its default; `cmc config` shows the settings in force and any problem in the file; the hub's Settings view and
  135. `cmc config set <mode> <value>` switch the modes.
  136. ```json
  137. {
  138. "holdPrefix": ";;",
  139. "dispatchPrefix": ">>",
  140. "sendAtEnd": true,
  141. "holdTarget": "main",
  142. "panelAutoOpen": true,
  143. "dispatch": {
  144. "context": "fork",
  145. "return": "held",
  146. "model": "inherit",
  147. "effort": "inherit",
  148. "permissionMode": "acceptEdits",
  149. "tools": ["Read", "Glob", "Grep", "Edit", "Write"],
  150. "restrictTools": true,
  151. "ignoreChanges": [],
  152. "keepOpenMinutes": 10
  153. },
  154. "retentionDays": 30
  155. }
  156. ```
  157. | Setting | Values |
  158. |---|---|
  159. | `holdPrefix`, `dispatchPrefix` | 1 to 4 symbols, no letters, digits, spaces or `/`; one cannot start the other. |
  160. | `sendAtEnd` | `true`: held messages reach the agent when its turn ends. `false`: they wait until you send them. |
  161. | `holdTarget` | `main` or `subagent` (a held message starts a subagent). |
  162. | `panelAutoOpen` | `true`: the hub opens by itself when something is held or a subagent starts. |
  163. | `dispatch.context`, `dispatch.return` | `fork` / `pack`; `held` / `auto`. Flags override them per task. |
  164. | `dispatch.model`, `dispatch.effort` | `inherit` (your own setup), an alias or full model name; `low` … `max`. |
  165. | `dispatch.permissionMode` | `acceptEdits`, `default` or `plan`. `bypassPermissions` is never accepted. |
  166. | `dispatch.tools`, `dispatch.restrictTools` | Tools the subagent may use (as `--allowedTools` takes them), and whether it has only those. |
  167. | `dispatch.ignoreChanges` | Paths other tools write into a subagent's worktree, e.g. `[".corvusmem/"]`: not counted as its work. |
  168. | `dispatch.keepOpenMinutes` | How long a subagent's session stays open for your messages after it answers (0 to 240). |
  169. | `retentionDays` | Sessions inactive for longer are deleted with their queue. `0` keeps them forever. |
  170. A wrong value never stops the plugin: that setting falls back to its default and the problem is shown when the next
  171. session starts and in `cmc config`.
  172. ## Known limits
  173. - **Terminal only.** Plugins installed from a repository do not reach Claude Code on the web (cloud sessions). The
  174. desktop app's Code tab loads plugins in local sessions but has not been tested.
  175. - **Send while the agent works needs your Ctrl+Enter**, as explained above.
  176. - **Resuming a subagent after its worktree was removed** (it changed nothing) may fail: Claude Code keeps a session's
  177. conversation per folder. The hub shows the error; start a new subagent instead.
  178. - **`--continue` and subagents.** `claude --continue` resumes the most recent conversation in the folder; a subagent that
  179. worked in the same folder (no git) is more recent. Use `claude --resume <id>`.
  180. - **Tested on Windows 11** with Claude Code 2.1.330 and Node 24. It is written for macOS and Linux too (paths, file modes,
  181. process handling), but the test suite has not been run there yet.
  182. - **Model behaviour.** What the agent does with what you send is up to the model. Messages and subagent reports are
  183. labelled for what they are, and in every test so far the agent acted on them as expected.
  184. ## Security
  185. cmc works only on your machine: no network calls, no runtime dependencies. Held messages, logs, conversations and agent
  186. outputs are stored in the plugin data directory, readable by your user only (on macOS and Linux). Text the plugin
  187. quotes from the session or from a subagent is labelled and fenced, and subagents never run with `bypassPermissions`.
  188. ## Development
  189. ```
  190. npm install # development only: TypeScript and the Node type definitions
  191. npm test # node --test (with test-support/setup.ts)
  192. npm run types # tsc --noEmit, strict
  193. npm run lint # syntax check of every module
  194. claude plugin validate . # the marketplace
  195. claude plugin validate ./plugins/cmc # the plugin
  196. ```
  197. `node scripts/e2e.ts` drives a real headless Claude Code session with this checkout loaded and types messages into it
  198. while it works (it spends tokens, so it is not part of `npm test`). [docs/manual-test.md](docs/manual-test.md) has the
  199. scenarios, including the checks of the hub that need the interactive terminal.
  200. Why cmc works the way it does is in the design records: [capture and release](docs/adr/001-capture-and-release.md),
  201. [dispatch and context](docs/adr/002-dispatch-and-context.md) and [the control panel](docs/adr/003-control-panel.md).
  202. ## Author
  203. Peterson Sena · [r3v3rs3](https://github.com/petersonsenadevs)

Ratings and comments

Sign in to rate this skill.

Sign in

Free to use. If it’s helped, pass it on.