Skip to content
Back to search

moa7amed-tools

MarketplaceWorks with Claude CodeGitHub

Developer tools for AI-assisted coding, published by moa7amed.

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/moa7amed--moa7amed-tools/badge.svg)](/listings/moa7amed--moa7amed-tools)

HTML

<a href="/listings/moa7amed--moa7amed-tools"><img src="/api/listings/moa7amed--moa7amed-tools/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.

The install commands run **in a terminal** and use the Claude Code CLI (`claude`). Inside a Claude Code session the same steps are `/plugin marketplace add ...` and `/plugin install ...`.

**From GitHub (recommended):**

# in a terminal
claude plugin marketplace add moa7amed/moa7amed-tools
claude plugin install moa7amed-queue@moa7amed-tools

**From a local clone:**

# in a terminal
git clone https://github.com/moa7amed/moa7amed-tools
claude plugin marketplace add ./moa7amed-tools
claude plugin install moa7amed-queue@moa7amed-tools

A marketplace added from a folder receives no automatic updates; run `claude plugin marketplace update moa7amed-tools` after pulling new commits.

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 · 28 lines
  1. {
  2. "name": "moa7amed-tools",
  3. "description": "Developer tools for AI-assisted coding, published by moa7amed.",
  4. "owner": {
  5. "name": "moa7amed",
  6. "email": "moa7amed@gmail.com",
  7. "url": "https://moa7amed.com/"
  8. },
  9. "plugins": [
  10. {
  11. "name": "moa7amed-queue",
  12. "source": "./plugins/moa7amed-queue",
  13. "description": "Intelligent AI Coding Task Orchestrator. Queue. Route. Execute. Verify. Prompts become persistent tasks that an external runner executes one at a time, each on the Claude model its difficulty calls for, with locking, crash recovery, dependencies, retries and git tracking.",
  14. "category": "productivity",
  15. "tags": [
  16. "queue",
  17. "tasks",
  18. "orchestration",
  19. "automation",
  20. "runner",
  21. "git",
  22. "model-routing"
  23. ],
  24. "homepage": "https://github.com/moa7amed/moa7amed-tools/tree/main/plugins/moa7amed-queue",
  25. "license": "MIT"
  26. }
  27. ]
  28. }
README.md · README · 312 lines
  1. # moa7amed-tools
  2. **moa7amed-queue is an intelligent task orchestrator plugin for Claude Code.** It is
  3. published in moa7amed-tools, a free, open-source marketplace of
  4. [Claude Code](https://code.claude.com/docs) plugins, created by **Mohamed Ibrahim
  5. Ramadan** and published as **moa7amed** ([moa7amed.com](https://moa7amed.com/),
  6. moa7amed@gmail.com). It is installed into Claude Code and executes queued tasks with the
  7. Claude Code CLI; it is not a Codex or Cursor extension (see [Compatibility](#compatibility)).
  8. > **Status: published.** moa7amed-queue 0.8.0 is available from this repository's
  9. > marketplace on GitHub. Installing 0.8.0 from GitHub into an empty Claude Code profile was verified on 2026-11-21, and CI passes on Linux, Windows and macOS. Real Claude Code
  10. > execution has been verified on Windows only, and updating from one published version to
  11. > the next has not been tested yet: 0.8.0 is the first.
  12. ## moa7amed-queue
  13. ![moa7amed-queue by moa7amed: Queue. Route. Execute. Verify. A persistent task queue for Claude Code.](docs/media/images/banner.png)
  14. **Intelligent AI Coding Task Orchestrator. Queue. Route. Execute. Verify.**
  15. ### See it run
  16. [![Video thumbnail: the moa7amed-queue title card. Opens the demo page.](docs/media/images/video-thumbnail.png)](docs/demo.md)
  17. [Watch the demo](docs/demo.md) (silent, with English or Arabic captions; about 2½ minutes,
  18. or 40 seconds for the short cut). It replays a real session on a small synthetic project:
  19. three tasks are queued and routed (a typo fix to Haiku, a feature to Sonnet, a security
  20. fix to the DEEP workflow, set to Sonnet by hand); the runner executes them one at a time;
  21. two read-only analysis agents examine the security fix at the same time; its plan waits
  22. for the owner's approval; every result is committed and verified, and the project's tests
  23. pass; a runner killed mid-task is recovered; BidStudio and Replica projects are started
  24. from local documents. Every terminal line in it is real output, replayed; long waits are
  25. sped up and labelled. More: [docs/demo.md](docs/demo.md), website
  26. [moa7amed.com](https://moa7amed.com/).
  27. Think of the next three things while Claude is still busy with the first, and queue them
  28. instead of interrupting it. Each prompt becomes a persistent task. A runner outside your
  29. session executes the tasks one at a time, each in a fresh Claude Code session, on the
  30. model its difficulty calls for, and commits each result.
  31. ### Key features
  32. | | |
  33. | :-- | :-- |
  34. | **Persistent queue** | Prompts and acceptance criteria are stored verbatim and cannot be edited or deleted. One queue per project, kept outside the project |
  35. | **Strictly sequential** | One runner per project, one task at a time, guarded by a lock |
  36. | **Model routing** | Each task runs on Haiku, Sonnet or Opus according to its difficulty, with manual overrides, fallback when a model is unavailable, and bounded escalation. Reads English, and Arabic (standard and Egyptian) |
  37. | **Your work is safe** | No task starts on top of uncommitted changes unless you allow it. Nothing is ever discarded; a separate git worktree is available |
  38. | **Crash recovery** | A task that finished before a crash is recorded, not run again; a task that was cut off is run again or held for your review. `reconcile` shows what was left behind and resolves it on your instruction |
  39. | **Cost controls** | A budget per task enforced by Claude Code, a limit per runner session, warnings, and a report of what each task cost |
  40. | **Adaptive workflow** | QUICK, STANDARD or DEEP process per task, decided from the task's analysis: no planning for a text change, a planning session and your approval for an architecture change, a verification report from every task. See [docs/workflow.md](docs/workflow.md) |
  41. | **Replica** | Rebuild an application from a URL, screenshots, recordings, source or specifications: evidence-classified screen and feature inventory, a plan you approve, building in the queue, measured screenshot comparison, real browser tests, bounded correction rounds, clean-room rules for third-party references. See [docs/replica.md](docs/replica.md) |
  42. | **BidStudio** | Tender analysis and proposals: every requirement quoted from its document, compliance matrix with evidence, clarifications and addenda with history, bid/no-bid, effort estimate, deterministic pricing (markup, margin, contingency, FX, tax), technical and commercial proposals (DOCX, PDF) and workbooks (XLSX) in English or Arabic, independent review. Never submits. See [docs/bidstudio.md](docs/bidstudio.md) |
  43. | **Multi-agent analysis (stage A)** | When justified, read-only analysis agents run concurrently in separate Claude Code sessions (tool-restricted, on a snapshot of HEAD, shared budget); the task's own session stays the only writer and verifies. Most tasks stay single; parallel implementation writes are not implemented. See [docs/agents.md](docs/agents.md) |
  44. | **Auto Queue** | Opt-in per project: a saved task starts a runner in the background when none is working; it runs eligible tasks one at a time and exits when idle. Pause, stop and an allowance for automatic runs; approvals and limits unchanged. See [docs/auto-queue.md](docs/auto-queue.md) |
  45. | **Challenge, then execute** | A task with a concrete risk (credentials in code, security switched off, data deleted, history rewritten, production or publishing) can wait for your decision: the concern, its evidence and an alternative, once. You take the recommendation or proceed with your approach; the decision is stored and followed, and never lifts permissions, approvals or cost limits. `/moa7amed-queue:grillme` reviews on request. See [docs/challenge.md](docs/challenge.md) |
  46. | **Project planning** | For new systems and major changes: requirements with evidence, the real deployment environment, architecture options checked against it, decision records, your explicit approval, and the approved tasks executed by the queue with a compliance check after each one. See [docs/planning.md](docs/planning.md) |
  47. | **Updates** | Through Claude Code's plugin mechanism, with a health check and automatic backups |
  48. ### Requirements
  49. Claude Code (tested with 2.1.329), Python 3.8 or newer (standard library only), git
  50. (recommended; needed for commits, snapshots and worktrees). On Windows, Git for Windows
  51. provides the `sh` the prompt-capture hook needs. Optional: a PDF text extractor for
  52. BidStudio, Playwright with Chromium for Replica captures and PDF output.
  53. ### Compatibility
  54. The current release, 0.8.0, is a Claude Code plugin. What works where:
  55. | Where | What works | Needs | Tested |
  56. | :-- | :-- | :-- | :-- |
  57. | **Claude Code CLI, plugin installed** (native) | Everything: the `/moa7amed-queue:...` skills, the `queue:` prompt hook, the runner, planning, Replica, BidStudio | Claude Code, Python 3.8+, git (recommended), `sh` for the hook | Real sessions with Claude Code 2.1.329 on Windows 11 only; installing from GitHub verified; test suites pass on Windows, Linux and macOS (CI) |
  58. | **`moa7amed-queue` command in a terminal** (standalone) | Queue management without a model: `add` (routing is local rules), `status`, `list`, `show`, `cancel`, `priority`, `config`, `usage`, and the `project`, `bid` and `replica` records | Python 3.8+ and the plugin's files (an installed plugin or a clone); see [the plugin README](plugins/moa7amed-queue/README.md#the-command-moa7amed-queue) | Windows, also with `claude` removed from `PATH`; Linux test suites |
  59. | **Executing tasks** (`run`, `launch`, the runners), from any terminal | Each task runs in a new Claude Code session (`claude -p`) | **The Claude Code CLI, installed and signed in.** Without it no task can start: the attempt is recorded as failed with the reason, and `doctor` reports Claude Code as missing | Windows with the real CLI |
  60. | **An editor's integrated terminal** (VS Code, Cursor, the shell of Codex or another tool) | The same as any terminal. This is terminal access, not an integration: tasks still run in Claude Code, not in the editor's own agent | As above | Not tested in Cursor or Codex |
  61. | **Claude Code's IDE extensions** (VS Code, JetBrains) | Not verified | | Not tested |
  62. | **Codex, Cursor or other agents, natively** | **Not implemented.** No adapters exist. Claude Code skills, hooks and plugin installation do not work in Codex or Cursor | | |
  63. | **macOS** | The test suites pass in CI (Python 3.10 and 3.13) | | No real Claude Code session on a Mac |
  64. ### Install
  65. The install commands run **in a terminal** and use the Claude Code CLI (`claude`). Inside
  66. a Claude Code session the same steps are `/plugin marketplace add ...` and
  67. `/plugin install ...`.
  68. **From GitHub (recommended):**
  69. ```bash
  70. # in a terminal
  71. claude plugin marketplace add moa7amed/moa7amed-tools
  72. claude plugin install moa7amed-queue@moa7amed-tools
  73. ```
  74. **From a local clone:**
  75. ```bash
  76. # in a terminal
  77. git clone https://github.com/moa7amed/moa7amed-tools
  78. claude plugin marketplace add ./moa7amed-tools
  79. claude plugin install moa7amed-queue@moa7amed-tools
  80. ```
  81. A marketplace added from a folder receives no automatic updates; run
  82. `claude plugin marketplace update moa7amed-tools` after pulling new commits.
  83. ### Quick start
  84. Install once → enable per project → submit with `queue:` → automatic execution.
  85. In a Claude Code session, in a project you trust, turn on Auto Queue once (it shows what
  86. that means and asks first):
  87. ```text
  88. /moa7amed-queue:auto enable
  89. queue: Add search to the customer page <- saved as task #1; a runner starts in the background
  90. queue: Add an export button to the report <- saved as task #2; it waits behind #1
  91. ```
  92. Claude Code puts each captured prompt back into the input box: press Esc twice before the
  93. next message. From a terminal, `moa7amed-queue add "..."` does the same without the prompt
  94. hook.
  95. Only `queue:` prompts and explicit queue-add requests become tasks; ordinary messages go to
  96. Claude as before. Without Auto Queue (the default for every project), tasks wait until you
  97. start a runner. See [docs/auto-queue.md](docs/auto-queue.md).
  98. Manual workflow, in a Claude Code session with the plugin installed:
  99. ```text
  100. /moa7amed-queue:queue-add Add input validation to the signup form. Acceptance criteria: invalid e-mail addresses are rejected with a message
  101. queue: Update the README for the new validation <- typed prefix, captured by the hook
  102. /moa7amed-queue:queue-status
  103. /moa7amed-queue:queue-run
  104. ```
  105. Or in any terminal, after creating the command once (`install-cli`, see
  106. [the plugin README](plugins/moa7amed-queue/README.md#the-command-moa7amed-queue)):
  107. `moa7amed-queue add "..."`, `moa7amed-queue status`, `moa7amed-queue run`. `run` needs
  108. the Claude Code CLI; `add` and `status` do not.
  109. ### Multi-agent example
  110. ```bash
  111. # in a terminal, in the project folder
  112. moa7amed-queue add "Fix the SQL injection in the login function and add regression tests"
  113. moa7amed-queue agents evaluate 1 # PARALLEL: 2 read-only subtasks (security_review, test_gap_analysis)
  114. moa7amed-queue run # both agents analyse at the same time on a snapshot of HEAD,
  115. # then the task's own session implements, tests and verifies
  116. moa7amed-queue agents show 1 # roles, pids, start/end, isolation, input revision, cost
  117. ```
  118. A text change (`"Update the login button text"`) runs as one session with no agents.
  119. Agents run concurrently only for justified, read-only analysis; the task's own session
  120. is always the only writer. Parallel implementation writes are not implemented.
  121. ### Commands
  122. | | |
  123. | :-- | :-- |
  124. | `add`, `status`, `list`, `show`, `history`, `log` | Queue and inspect tasks |
  125. | `priority`, `depend`, `retry`, `cancel` | Order and manage them |
  126. | `run`, `launch`, `plan` | Run the queue here, in the background, or show what would run |
  127. | `model`, `route`, `models` | Choose or inspect the model per task |
  128. | `reconcile`, `recover` | See and resolve what a crash left behind |
  129. | `project ...` | Plan a project: requirements, infrastructure, decisions, tasks, approval, import |
  130. | `usage` | What tasks cost, as Claude Code reported it |
  131. | `update`, `doctor`, `backup`, `restore`, `changelog` | Upkeep |
  132. ### Queueing while Claude is working
  133. Measured with Claude Code 2.1.329 in a real interactive session:
  134. - A message that **starts with `queue:`** is stored as a task the moment you press
  135. Enter, even while Claude is in the middle of a turn or a tool call. It is not sent to
  136. Claude, and the running work is not interrupted.
  137. - Claude Code then **puts that text back into the input box**. Press **Esc twice** to
  138. clear it. If you press Enter again, or type on and press Enter, the plugin recognises
  139. the repeat and does not queue it a second time.
  140. - A message **without** the prefix goes to Claude as usual (Claude Code queues it and
  141. hands it to Claude when the current tool calls finish). It does not enter the task
  142. queue.
  143. - If you need certainty that does not depend on the hook, use `moa7amed-queue add` in
  144. another terminal, or `/moa7amed-queue:queue-add` (Claude Code runs commands typed
  145. during a turn after that turn ends).
  146. ### Cost
  147. The plugin is free. Running tasks uses your Claude account, billed by Anthropic
  148. according to your plan; the plugin adds no charge of its own and needs no licence key.
  149. What the controls guarantee, and what they do not:
  150. | Control | What it does | Exact? |
  151. | :-- | :-- | :-- |
  152. | `max_budget_usd` | Passed to Claude Code (`--max-budget-usd`), which stops the task once its own cost estimate reaches it | No: the response that crosses the line still completes. Measured: a $0.01 budget stopped at $0.0138 |
  153. | `cost_limit_run_usd` | Starts no further task once the session reached it, and gives each task at most what is left as its budget | Between tasks, plus Claude Code's overshoot of the last task |
  154. | `cost_warn_task_usd`, `cost_warn_run_usd` | Warnings in the runner log | Warnings only |
  155. | `usage` | Totals per model and per task | Claude Code's figures, which it calls client-side estimates; your bill is the authority |
  156. A task stopped by its budget is not retried automatically.
  157. ### Security and privacy
  158. Queue data is stored on your machine, in `~/.moa7amed-queue`. The plugin itself opens no
  159. network connection and has no telemetry; the Claude Code sessions it starts for tasks send
  160. their prompts to the model provider under your Claude Code login, as any Claude Code session
  161. does. Tasks run unattended under the permission mode you choose (default `acceptEdits`). Details: [docs/security-and-privacy.md](docs/security-and-privacy.md).
  162. ### Limitations
  163. - Tasks are unattended: Claude cannot ask you questions, and permission prompts are
  164. denied.
  165. - Routing is a rule-based classifier with an optional one-line model review, not an
  166. oracle; its accuracy is measured on test sets only.
  167. - Tested on Windows 11 (Python 3.8, 3.9 and 3.14) and on Linux under WSL (Python
  168. 3.12). **macOS has not been tested**; the CI workflow covers it once the repository is
  169. on GitHub.
  170. - The interactive capture behaviour above was observed with Claude Code 2.1.329 on
  171. Windows. Claude Code does not document hook behaviour for messages typed during a
  172. turn, so it may differ in other versions.
  173. Full reference, settings and troubleshooting:
  174. [plugins/moa7amed-queue/README.md](plugins/moa7amed-queue/README.md).
  175. ## Updates
  176. ```bash
  177. claude plugin marketplace update moa7amed-tools
  178. claude plugin update moa7amed-queue@moa7amed-tools
  179. ```
  180. Claude Code can do this by itself, but for marketplaces other than its official one that
  181. is off until you turn it on: `/plugin`, **Marketplaces** tab, select `moa7amed-tools`,
  182. turn on auto-update. Going back to an earlier version:
  183. [docs/updates-and-rollback.md](docs/updates-and-rollback.md).
  184. ## Implemented and roadmap
  185. | Area | State |
  186. | :-- | :-- |
  187. | Persistent queue, sequential runner, locking, crash recovery, git safety | implemented |
  188. | Model routing (Haiku/Sonnet/Opus), manual overrides, fallback, escalation | implemented |
  189. | Adaptive workflow (QUICK/STANDARD/DEEP), verification reports | implemented |
  190. | Project planning with owner approval | implemented |
  191. | Replica, BidStudio | implemented (BidStudio never submits) |
  192. | Multi-agent stage A: one coordinator, concurrent read-only analysis agents, one writer | implemented (0.8.0) |
  193. | Challenge, discuss, then execute (`grillme`): evidence-backed concerns, owner decisions | implemented (0.8.0) |
  194. | Multi-agent stage B: parallel implementation writes with file ownership and integration | **roadmap, not implemented** |
  195. | Critical-path analysis, cost optimisation of architectures, drift detection beyond the post-task check, infrastructure benchmarking | roadmap |
  196. | Hosted marketplace on GitHub | published (0.8.0); installing from it verified |
  197. | Automatic updates between published versions | through Claude Code; not tested yet (needs a second published version) |
  198. ### Not verified yet
  199. - A real Claude Code session on macOS or Linux. Real execution was verified on Windows
  200. only; on Linux, Windows and macOS the test suites pass in CI, with a stand-in for
  201. Claude Code.
  202. - Updating from one published version to the next, including Claude Code's background
  203. auto-update, and adding the marketplace at a branch or tag.
  204. - Claude Code's IDE extensions (VS Code, JetBrains). Codex and Cursor have no native
  205. adapters: not implemented.
  206. - Multi-agent behaviour with Claude Code versions other than the one tested, and with
  207. MCP servers that write (outside the agents' tool restrictions).
  208. ## Troubleshooting
  209. `moa7amed-queue doctor` checks the installation; `moa7amed-queue status` shows holds
  210. (for example `agents:` or `approval:`); `moa7amed-queue reconcile` shows what a crash
  211. left behind. More: [Troubleshooting](plugins/moa7amed-queue/README.md#troubleshooting).
  212. Planned plugins, **not built**: `moa7amed-review` (reviewing a change before it is committed),
  213. `moa7amed-ui` (checking interface work), `moa7amed-qa` (test plans),
  214. `moa7amed-release` (release preparation for your own projects). The names are reserved;
  215. nothing in this repository depends on them.
  216. ## Repository
  217. ```text
  218. .claude-plugin/marketplace.json the marketplace
  219. plugins/moa7amed-queue/ the plugin: everything a user receives is in this folder
  220. docs/ contributor documentation
  221. scripts/ release tooling
  222. release/baselines.json earlier versions the upgrade tests start from
  223. .github/workflows/ CI and the release record
  224. tests/ checks for the marketplace as a whole
  225. ```
  226. | Documentation | |
  227. | :-- | :-- |
  228. | [Architecture](docs/architecture.md) | How the repository and the queue plugin are built |
  229. | [Project planning](docs/planning.md) | Planning before building, with a worked example |
  230. | [Plugin development](docs/plugin-development.md) | Adding a skill, agent, hook, MCP server or plugin |
  231. | [Writing skills](docs/skills-development.md) | The skill file, and what its description costs |
  232. | [Updates and rollback](docs/updates-and-rollback.md) | For users and maintainers |
  233. | [Versioning](docs/versioning.md) | Version numbers, compatibility, data format, channels |
  234. | [Release checklist](docs/release-checklist.md) | First public release, every release, a bad release |
  235. | [GitHub release steps](docs/github-release.md) | The exact steps the owner runs to publish 0.8.0 |
  236. | [Multi-agent execution](docs/agents.md) | Stage A: when agents run, enforcement, recovery, budgets |
  237. | [Challenge, discuss, then execute](docs/challenge.md) | Concerns, the owner's decisions, and what they cannot change |
  238. | [Auto Queue](docs/auto-queue.md) | Opt-in automatic runner per project: consent, pause, stop, idle timeout, allowance |
  239. | [Directory submission](docs/directory-submission.md) | Listing materials and the directory's findings (not submitted; the full plugin needs a Verified organization) |
  240. | [Changelog](plugins/moa7amed-queue/CHANGELOG.md) | What changed in each version |
  241. | [Security and privacy](docs/security-and-privacy.md) | What is stored, started and sent |
  242. | [Contributing](CONTRIBUTING.md) | Where to start |
  243. ## License
  244. [MIT](LICENSE). Copyright (c) 2026 Mohamed Ibrahim Ramadan (moa7amed). Free to use,
  245. modify and distribute, commercially or not. The plugins contain no third-party code;
  246. they use only the Python standard library and the programs already on your machine
  247. (Claude Code, git). Each plugin folder carries its own copy of the license.

Ratings and comments

Sign in to rate this skill.

Sign in

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