Skip to content
Back to search

helloagents

MarketplaceWorks with Claude CodeGitHub

Official marketplace for the HelloAGENTS quality-driven orchestration kernel

Safety scan

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

Checked today
Badge for your README
findsafeskills safety rating

Markdown

[![findsafeskills safety rating](/api/listings/hellowind777--helloagents/badge.svg)](/listings/hellowind777--helloagents)

HTML

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

1) Install the package

npm install -g --allow-scripts=helloagents helloagents

If another executable named `helloagents` already exists in your `PATH`, use the stable managed-entry alias:

helloagents-js

By default, `postinstall` installs the package command, initializes `~/.helloagents/helloagents.json`, and syncs runtime files to `~/.helloagents/helloagents`. No host CLI is deployed unless you set `HELLOAGENTS=target[:mode]`, such as `HELLOAGENTS=codex:global`.

For npm 11 and later, keep `--allow-scripts=helloagents` on direct package install or upgrade commands so npm can run the managed `postinstall` without approval warnings. If you are still on npm 10 or earlier, you can omit that flag.

2) Deploy to a CLI

Use standby mode for selected projects and explicit activation:

helloagents install codex --standby
helloagents install --all --standby

Use global mode when you want full rules everywhere:

helloagents --global
helloagents install --all --global

After reinstalling, refreshing, or switching modes, restart the target AI CLI or open a new session; already running sessions do not reload injected rules automatically.

3) Verify inside your AI CLI

Type:

~help

You should see the available chat commands and the current settings.

4) Create project knowledge

Initialize the project workflow:

~init

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 · 19 lines

View this file on GitHub (read at the repository's current version: the scan did not record which commit it read)

  1. {
  2. "name": "helloagents",
  3. "description": "Official marketplace for the HelloAGENTS quality-driven orchestration kernel",
  4. "owner": {
  5. "name": "HelloWind",
  6. "email": "hellowind777@gmail.com"
  7. },
  8. "plugins": [
  9. {
  10. "name": "helloagents",
  11. "description": "Quality-driven orchestration kernel for AI CLIs: intelligent routing, quality verification, safety guards, and notifications",
  12. "source": "./",
  13. "author": {
  14. "name": "HelloWind",
  15. "email": "hellowind777@gmail.com"
  16. }
  17. }
  18. ]
  19. }
README.md · README · 858 lines · 10 findings marked

View this file on GitHub (read at the repository's current version: the scan did not record which commit it read)

  1. <div align="center">
  2. <img src="./readme_images/01-hero-banner.svg" alt="HelloAGENTS" width="800">
  3. </div>
  4. # HelloAGENTS
  5. <div align="center">
  6. **A workflow layer for AI coding CLIs: skills, project knowledge, delivery checks, safer config writes, and resumable execution.**
  7. [![Version](https://img.shields.io/badge/version-3.1.9-orange.svg)](./package.json)
  8. [![npm](https://img.shields.io/npm/v/helloagents.svg)](https://www.npmjs.com/package/helloagents)
  9. [![Node](https://img.shields.io/badge/node-%3E%3D18-339933.svg)](./package.json)
  10. [![Skills](https://img.shields.io/badge/skills-14-6366f1.svg)](./skills)
  11. [![License](https://img.shields.io/badge/license-Apache--2.0-blue.svg)](./LICENSE.md)
  12. [![PRs Welcome](https://img.shields.io/badge/PRs-welcome-brightgreen.svg)](https://github.com/hellowind777/helloagents/issues)
  13. [![LINUX DO](https://img.shields.io/badge/LINUX_DO-recognized-0A84FF?logo=linux&logoColor=white)](https://linux.do)
  14. </div>
  15. <p align="center">
  16. <a href="./README.md"><img src="https://img.shields.io/badge/English-blue?style=for-the-badge" alt="English"></a>
  17. <a href="./README_CN.md"><img src="https://img.shields.io/badge/简体中文-blue?style=for-the-badge" alt="简体中文"></a>
  18. </p>
  19. ---
  20. > [!IMPORTANT]
  21. > Looking for `v2.x`? The old Python line now lives in [helloagents-archive](https://github.com/hellowind777/helloagents-archive). The `v3` line is a full rewrite based on Node.js, Markdown rules, skills, and small runtime scripts.
  22. > 🏅 This project is linked & recognized by the [LINUX DO](https://linux.do) community.
  23. ## Contents
  24. - [What HelloAGENTS Does](#what-helloagents-does)
  25. - [Core Features](#core-features)
  26. - [Quick Start](#quick-start)
  27. - [CLI Management](#cli-management)
  28. - [Commands in Chat](#commands-in-chat)
  29. - [Project Knowledge Base](#project-knowledge-base)
  30. - [Workflow and Delivery](#workflow-and-delivery)
  31. - [Configuration](#configuration)
  32. - [How Each CLI Is Integrated](#how-each-cli-is-integrated)
  33. - [Verification](#verification)
  34. - [FAQ](#faq)
  35. - [Troubleshooting](#troubleshooting)
  36. - [License](#license)
  37. ## What HelloAGENTS Does
  38. AI coding CLIs can move fast, but they can also stop at advice, skip checks, lose project context, shift responsibility when tasks get hard, or report completion before the work is really done.
  39. HelloAGENTS adds a workflow layer on top of Claude Code, Gemini CLI, Grok Build, Cursor, and Codex CLI. It anchors the agent as a capable executor, blocks responsibility-shifting patterns, helps the agent choose the right path, use task-specific quality skills, keep a project knowledge base, and verify work before delivery.
  40. <table>
  41. <tr>
  42. <td width="50%" valign="top" align="center">
  43. **Without HelloAGENTS**
  44. <img src="./readme_images/08-demo-snake-without-helloagents.png" alt="Without HelloAGENTS" width="520">
  45. </td>
  46. <td width="50%" valign="top" align="center">
  47. **With HelloAGENTS**
  48. <img src="./readme_images/07-demo-snake-with-helloagents.png" alt="With HelloAGENTS" width="520">
  49. </td>
  50. </tr>
  51. </table>
  52. | Problem | Without HelloAGENTS | With HelloAGENTS |
  53. |---------|---------------------|------------------|
  54. | Stops too early | Ends with suggestions | Continues into build, verify, and closeout |
  55. | Shifts responsibility | Refuses hard tasks, suggests other tools | Exhausts alternative paths, stays on task |
  56. | Quality is inconsistent | Depends on each prompt | 14 quality skills activate by task type |
  57. | Context is scattered | Plans live in chat history | Project knowledge and plan files stay on disk |
  58. | Completion is vague | Natural language says “done” | Delivery checks use state, evidence, and verification |
  59. | Config writes are risky | CLI files can drift | Install, update, cleanup, and doctor flows check managed files |
  60. ## Core Features
  61. ### 1) 14 built-in workflow skills
  62. HelloAGENTS ships 14 built-in skills. They are loaded only when the current stage needs them, so simple tasks stay light while complex work gets stricter checks.
  63. | Skill | Focus |
  64. |-------|-------|
  65. | `hello-ui` | UI planning, design contracts, implementation mapping, visual validation |
  66. | `hello-api` | API design, validation, error format, compatibility |
  67. | `hello-security` | auth, secrets, permissions, injection risks |
  68. | `hello-test` | TDD, coverage, edge cases, test structure |
  69. | `qa-review` | unified quality review, verification commands, blocking fixes, delivery evidence, closeout |
  70. | `helloagents` | command routing, workflow stage rules, project knowledge, and state coordination |
  71. | `hello-errors` | error handling, logs, retry and recovery behavior |
  72. | `hello-perf` | performance, caching, query and rendering risks |
  73. | `hello-data` | database, migrations, transactions, indexes |
  74. | `hello-arch` | architecture, boundaries, code size, maintainability |
  75. | `hello-debug` | bug diagnosis and escalation when stuck |
  76. | `hello-subagent` | subagent delegation and result integration |
  77. | `hello-write` | documentation, reports, and written deliverables |
  78. | `hello-reflect` | reusable lessons and knowledge updates |
  79. All UI work first follows the shared UI quality baseline.
  80. In host global mode, in initialized projects, or in explicit UI workflows, `hello-ui` adds deeper design-contract execution, design-system mapping, and visual validation on top of that baseline.
  81. When visual evidence is required, HelloAGENTS records it in the current session `artifacts/visual.json`.
  82. ### 2) Commands for different work styles
  83. Commands run inside the AI CLI chat with a `~` prefix. The command skill is read directly; unrelated skills are not loaded unless the workflow needs them.
  84. | Command | Purpose |
  85. |---------|---------|
  86. | `~ask` | Interactive clarification: Q&A to pin down goals, direction, scope, and constraints; does not write files |
  87. | `~auto` | Chooses the main path and keeps going until delivery or a real blocker |
  88. | `~plan` | Requirements, solution design, task breakdown, and plan package |
  89. | `~build` | Implementation from the current request or an existing plan |
  90. | `~prd` | Modern product requirements document through guided dimension-by-dimension exploration |
  91. | `~loop` | Long-running entry; in Codex it prefers `/goal -> ~auto -> ~qa` |
  92. | `~init` | Initialize the project workflow and sync project knowledge |
  93. | `~test` | Write tests for a target module or recent change |
  94. | `~qa` | Run the unified quality loop: review, verification commands, fixes, and closeout |
  95. | `~commit` | Generate a conventional commit message and sync knowledge |
  96. | `~clean` | Archive finished plans and clean temporary runtime files |
  97. | `~help` | Show commands and current settings |
  98. Compatibility aliases:
  99. - `~do` → `~build`
  100. - `~design` → `~plan`
  101. - `~review` → `~qa`
  102. - `~idea` → `~ask` (deprecated)
  103. Use `~ask` for clarifying requirements, comparing approaches, weighing value, and scoping — pure conversation, no files created.
  104. ### 3) Project knowledge base
  105. HelloAGENTS can create and maintain a project knowledge base under `.helloagents/`.
  106. The knowledge base helps future turns understand the repo without re-discovering the same facts. It can store:
  107. | File or directory | Purpose |
  108. |-------------------|---------|
  109. | `context.md` | project overview, stack, architecture, module index |
  110. | `guidelines.md` | non-obvious coding conventions inferred from the repo |
  111. | `verify.yaml` | verification commands such as lint, test, build |
  112. | `CHANGELOG.md` | project-level change history |
  113. | `DESIGN.md` | stable UI design contract when the project has UI work |
  114. | `modules/*.md` | module-specific notes and lessons |
  115. | `plans/<feature>/` | active plan packages |
  116. | `archive/` | archived plan packages |
  117. `~init` initializes the project workflow: it writes the project-level full carrier marker, prepares project state, and creates or updates the knowledge base.
  118. ### 4) Structured plan packages
  119. Complex work can be stored as plan packages instead of a single paragraph in chat.
  120. For `~plan`, HelloAGENTS uses:
  121. - `requirements.md`
  122. - `plan.md`
  123. - `tasks.md`
  124. - `contract.json`
  125. For `~prd`, HelloAGENTS also creates PRD files such as:
  126. - `prd/00-overview.md`
  127. - `prd/01-user-stories.md`
  128. - `prd/02-functional.md`
  129. - `prd/03-ui-design.md`
  130. - `prd/04-technical.md`
  131. - `prd/05-nonfunctional.md`
  132. - `prd/06-i18n-l10n.md`
  133. - `prd/07-accessibility.md`
  134. - `prd/08-content.md`
  135. - `prd/09-testing.md`
  136. - `prd/10-deployment.md`
  137. - `prd/11-legal-privacy.md`
  138. - `prd/12-timeline.md`
  139. `contract.json` is used by the workflow to decide `qaMode`, `qaFocus`, optional advisor checks, and optional visual validation.
  140. `tasks.md` also includes a Codex `/goal` entry. For long-running Codex work, use that prepared entry instead of giving `/goal` a raw product document. The default chain is `/goal -> ~auto -> ~qa`: Codex keeps the long-running continuation, `~auto` executes the AFK work, and `~qa` remains the final quality gate before closeout.
  141. ### 5) State and recovery
  142. Long tasks need a small recovery snapshot, but one shared state file is not safe enough for concurrent work.
  143. HelloAGENTS now resolves the current state file from `state_path`:
  144. - with a stable or reusable session id: `.helloagents/sessions/<workspace>/<session>/STATE.md`
  145. - before a reusable session id is available: `.helloagents/sessions/<workspace>/default/STATE.md`
  146. `<workspace>` is the current Git branch, `detached-<sha>` for a detached HEAD, or `workspace` for non-Git projects. `<session>` is the current project-local session token. `.helloagents/sessions/active.json` only keeps the latest active workspace/session mapping plus alias bridges, so the same CLI session stays in one directory and `/resume` can reuse it.
  147. For project-local sessions, HelloAGENTS first uses stable host identifiers such as `sessionId`, `conversationId`, `threadId`, or `HELLOAGENTS_NOTIFY_SESSION_ID`. If the host only exposes a window or terminal id such as `WT_SESSION`, `TERM_SESSION_ID`, or `WINDOWID`, HelloAGENTS uses it only as a lightweight alias bridge and reuses the mapped session first instead of fanning out duplicate directories. If a session starts before a stable host identifier is available, HelloAGENTS can begin in `default` and keep reusing that same active directory after the same CLI session later exposes a stable identifier, instead of splitting into a second session directory.
  148. `STATE.md` records where the current workflow stopped. It is not a universal memory file for every conversation. Codex `/goal` does not replace `state_path`, `turn-state`, or local evidence files; it only handles long-running continuation on the Codex side.
  149. ### 6) Verification and delivery evidence
  150. HelloAGENTS does not treat “tests passed” and “task complete” as the same thing. Delivery can also require plan coverage, task checklist status, review evidence, advisor evidence, and visual evidence.
  151. Runtime state now stays intentionally small:
  152. - `.helloagents/sessions/<workspace>/<session>/STATE.md`
  153. - `.helloagents/sessions/<workspace>/<session>/runtime.json`
  154. - `.helloagents/sessions/active.json`
  155. - `.helloagents/sessions/<workspace>/<session>/artifacts/qa-review.json`
  156. - `.helloagents/sessions/<workspace>/<session>/artifacts/advisor.json`
  157. - `.helloagents/sessions/<workspace>/<session>/artifacts/visual.json`
  158. - `.helloagents/sessions/<workspace>/<session>/artifacts/closeout.json`
  159. - optional `.helloagents/sessions/<workspace>/<session>/events.jsonl`
  160. - `~/.codex/.helloagents/notify-state.json` for Codex-native closeout de-duplication only
  161. `STATE.md` only keeps the human-readable recovery snapshot. `runtime.json` is machine-only and keeps the minimal runtime state. `artifacts/*.json` stays limited to structured receipts. `events.jsonl` remains opt-in trace output and stays off by default.
  162. Project-local `STATE.md` is now materialized more lazily.
  163. Standard runtime evidence and transient runtime state now expire after 72 hours. Long-running Codex goal flows still keep their 720-hour upper bound where the workflow explicitly needs it.
  164. Delivery gate, guard, and QA gate messages use action-oriented wording such as processing path, closeout action, and visual validation action, so blocked flows show what to do next without turning executable steps into optional suggestions. Final closeout also enforces a single HelloAGENTS wrapper, so one reply does not emit duplicate closeout headers.
  165. That wrapper is now reserved for direct final-user delivery only. Intermediate reports, delegated task results, and sub-agent replies stay natural, and sub-agent stop hooks reject wrapped closeout replies.
  166. ### 7) Safer install, update, cleanup, and diagnostics
  167. The CLI manages host files explicitly:
  168. - `install` writes only the selected target unless `--all` is used
  169. - `update` refreshes the selected target or all targets
  170. - `cleanup` removes managed injections and links
  171. - `uninstall` performs scoped cleanup before package removal
  172. - `doctor` reports drift in carriers, links, hooks, config entries, plugin roots, cache copies, versions, and real Claude/Gemini global install artifacts; for Codex, it also surfaces native `codex doctor` output when available
  173. - Codex managed `notify = ["helloagents-js", "codex-notify"]` stays portable, and `doctor`, `cleanup`, and `uninstall` also recognize wrapped `--previous-notify` chains used by Codex App / Computer Use
  174. - per-host mode tracking is written only after host setup succeeds, and failed native global cleanup keeps the host tracked as `global` instead of silently layering standby on top
  175. - direct `switch-branch` clears stale `HELLOAGENTS*` lifecycle env before its internal npm install/sync steps, and package `preuninstall` falls back to `--all` when no explicit host args are provided, so stale shell env does not shrink branch-switch or uninstall cleanup scope
  176. - Windows `.cmd` / `.bat` lifecycle calls now run through an explicit command wrapper, so host installs, branch switching, and doctor flows do not emit Node `DEP0190` shell deprecation warnings
  177. - Claude Code, Gemini CLI, Grok Build, Cursor, and Codex CLI config writes, updates, cleanup, uninstall, mode switching, and branch switching are covered as one tested lifecycle chain instead of separate best-effort paths
  178. ## Quick Start
  179. ### 1) Install the package
  180. ```bash
  181. npm install -g --allow-scripts=helloagents helloagents
  182. ```
  183. If another executable named `helloagents` already exists in your `PATH`, use the stable managed-entry alias:
  184. ```bash
  185. helloagents-js
  186. ```
  187. By default, `postinstall` installs the package command, initializes `~/.helloagents/helloagents.json`, and syncs runtime files to `~/.helloagents/helloagents`. No host CLI is deployed unless you set `HELLOAGENTS=target[:mode]`, such as `HELLOAGENTS=codex:global`.
  188. For npm 11 and later, keep `--allow-scripts=helloagents` on direct package install or upgrade commands so npm can run the managed `postinstall` without approval warnings. If you are still on npm 10 or earlier, you can omit that flag.
  189. ### 2) Deploy to a CLI
  190. Use standby mode for selected projects and explicit activation:
  191. ```bash
  192. helloagents install codex --standby
  193. helloagents install --all --standby
  194. ```
  195. Use global mode when you want full rules everywhere:
  196. ```bash
  197. helloagents --global
  198. helloagents install --all --global
  199. ```
  200. After reinstalling, refreshing, or switching modes, restart the target AI CLI or open a new session; already running sessions do not reload injected rules automatically.
  201. ### 3) Verify inside your AI CLI
  202. Type:
  203. ```text
  204. ~help
  205. ```
  206. You should see the available chat commands and the current settings.
  207. ### 4) Create project knowledge
  208. Initialize the project workflow:
  209. ```text
  210. ~init
  211. ```
  212. ## CLI Management
  213. ### Shell commands
  214. ```bash
  215. helloagents --standby
  216. helloagents --global
  217. helloagents install codex --standby
  218. helloagents install --all --global
  219. helloagents update codex
  220. helloagents cleanup claude --global
  221. helloagents uninstall gemini
  222. helloagents switch-branch beta
  223. helloagents switch-branch beta claude --global
  224. helloagents doctor
  225. helloagents doctor codex --json
  226. helloagents codex goals status
  227. helloagents codex goals enable
  228. ```
  229. Supported targets:
  230. - `claude`
  231. - `gemini`
  232. - `grok`
  233. - `cursor`
  234. - `codex`
  235. - `--all`
  236. If you omit `--standby` or `--global`, HelloAGENTS first reuses the tracked/detected mode for that CLI, then falls back to `standby`.
  237. ### npm and one-shot script entries
  238. Use these when you do not want to depend on the `helloagents` binary being available during package updates. In `HELLOAGENTS=target[:mode]`, target can be `all`, `claude`, `gemini`, `grok`, `cursor`, or `codex`; mode can be `standby` or `global`. For install, an omitted mode is treated as `standby`. For update, cleanup, uninstall, and branch switching, an omitted mode is forwarded unchanged so HelloAGENTS can reuse the tracked or detected mode for that CLI first. If you do not provide `HELLOAGENTS`, the one-shot install scripts now behave like plain package install: they install or update the package only and do not auto-deploy any host CLI. For a custom tarball or package spec, set `HELLOAGENTS_PACKAGE` instead of `HELLOAGENTS_BRANCH`. For a guaranteed refresh of an already installed package, prefer `npm explore -g helloagents -- npm run sync-hosts -- ...` after the package command. The one-shot shell and PowerShell wrappers auto-detect npm 11+ and append `--allow-scripts=helloagents` only where that flag is supported.
  239. Host configs use the stable `helloagents-js` entrypoint and runtime root `~/.helloagents/helloagents`, so Node global package paths can change without breaking managed hooks or Codex `notify`. Codex hooks use standalone `~/.codex/hooks.json` instead of adding large hook blocks to `config.toml`, and Codex global plugin roots plus plugin cache now link back to that same stable runtime root. Claude Code global installs use a dedicated local marketplace projection under `~/.helloagents/host-projections/claude-marketplace`, Gemini global extension packaging uses `~/.helloagents/host-projections/gemini`, Grok Build global installs use the materialized marketplace projection `~/.helloagents/host-projections/helloagents-grok-marketplace`, and Cursor global installs use the curated local-plugin projection `~/.helloagents/host-projections/cursor-local-plugin/helloagents` plus a real copied install directory at `~/.cursor/plugins/local/helloagents`, so host-specific packaging stays isolated from the shared runtime root without relying on symlink-only plugin loading.
  240. #### npm commands
  241. macOS / Linux:
  242. ```bash
  243. # Install to Codex in standby mode
  244. HELLOAGENTS=codex npm install -g --allow-scripts=helloagents helloagents
  245. # Install to Codex in global mode
  246. HELLOAGENTS=codex:global npm install -g --allow-scripts=helloagents helloagents
  247. # Update the package, then refresh Claude in standby mode
  248. npm install -g --allow-scripts=helloagents helloagents@latest
  249. npm explore -g helloagents -- npm run sync-hosts -- claude --standby
  250. # Switch to the beta branch, then refresh all CLIs in standby mode
  251. npm install -g --allow-scripts=helloagents https://github.com/hellowind777/helloagents/archive/refs/heads/beta.tar.gz
  252. npm explore -g helloagents -- npm run sync-hosts -- --all --standby
  253. # Clean Gemini integration before package uninstall
  254. npm explore -g helloagents -- npm run uninstall -- gemini --standby
  255. npm uninstall -g helloagents
  256. ```
  257. Windows PowerShell:
  258. ```powershell
  259. # Install to Codex in standby mode
  260. $env:HELLOAGENTS="codex"; npm install -g --allow-scripts=helloagents helloagents
  261. # Install to Codex in global mode
  262. $env:HELLOAGENTS="codex:global"; npm install -g --allow-scripts=helloagents helloagents
  263. # Update the package, then refresh Claude in standby mode
  264. npm install -g --allow-scripts=helloagents helloagents@latest
  265. npm explore -g helloagents -- npm run sync-hosts -- claude --standby
  266. # Switch to the beta branch, then refresh all CLIs in standby mode
  267. npm install -g --allow-scripts=helloagents https://github.com/hellowind777/helloagents/archive/refs/heads/beta.tar.gz
  268. npm explore -g helloagents -- npm run sync-hosts -- --all --standby
  269. # Clean Gemini integration before package uninstall
  270. npm explore -g helloagents -- npm run uninstall -- gemini --standby
  271. npm uninstall -g helloagents
  272. ```
  273. After the package is installed, you can also call its npm scripts directly:
  274. ```bash
  275. npm explore -g helloagents -- npm run deploy:global
  276. npm explore -g helloagents -- npm run sync-hosts -- --all --standby
  277. npm explore -g helloagents -- npm run cleanup-hosts -- codex --standby
  278. npm explore -g helloagents -- npm run uninstall -- --all
  279. ```
  280. Fresh installs can still use `HELLOAGENTS=target[:mode]` directly. For update, branch switching, or any forced host re-sync of an already installed package, the explicit `npm run sync-hosts` step above is the deterministic path.
  281. #### One-shot scripts
  282. macOS / Linux:
  283. ```bash
  284. # Install
  285. HELLOAGENTS=codex curl -fsSL https://raw.githubusercontent.com/hellowind777/helloagents/main/install.sh | sh
    • Note: Pipes a downloaded script directly into a shell (curl | sh / wget | bash)
    • Line 395 on GitHub
  286. # Update
  287. HELLOAGENTS=claude:standby HELLOAGENTS_ACTION=update curl -fsSL https://raw.githubusercontent.com/hellowind777/helloagents/main/install.sh | sh
    • Note: Pipes a downloaded script directly into a shell (curl | sh / wget | bash)
    • Line 398 on GitHub
  288. # Switch branch
  289. HELLOAGENTS=all:global HELLOAGENTS_ACTION=switch-branch HELLOAGENTS_BRANCH=beta curl -fsSL https://raw.githubusercontent.com/hellowind777/helloagents/main/install.sh | sh
    • Note: Pipes a downloaded script directly into a shell (curl | sh / wget | bash)
    • Line 401 on GitHub
  290. # Cleanup host integration without uninstalling the package
  291. HELLOAGENTS=codex:standby HELLOAGENTS_ACTION=cleanup curl -fsSL https://raw.githubusercontent.com/hellowind777/helloagents/main/install.sh | sh
    • Note: Pipes a downloaded script directly into a shell (curl | sh / wget | bash)
    • Line 404 on GitHub
  292. # Uninstall
  293. HELLOAGENTS=gemini HELLOAGENTS_ACTION=uninstall curl -fsSL https://raw.githubusercontent.com/hellowind777/helloagents/main/install.sh | sh
    • Note: Pipes a downloaded script directly into a shell (curl | sh / wget | bash)
    • Line 407 on GitHub
  294. ```
  295. Windows PowerShell:
  296. ```powershell
  297. # Install
  298. $env:HELLOAGENTS="codex"; irm https://raw.githubusercontent.com/hellowind777/helloagents/main/install.ps1 | iex
  299. # Update
  300. $env:HELLOAGENTS="claude:standby"; $env:HELLOAGENTS_ACTION="update"; irm https://raw.githubusercontent.com/hellowind777/helloagents/main/install.ps1 | iex
  301. # Switch branch
  302. $env:HELLOAGENTS="all:global"; $env:HELLOAGENTS_ACTION="switch-branch"; $env:HELLOAGENTS_BRANCH="beta"; irm https://raw.githubusercontent.com/hellowind777/helloagents/main/install.ps1 | iex
  303. # Cleanup host integration without uninstalling the package
  304. $env:HELLOAGENTS="codex:standby"; $env:HELLOAGENTS_ACTION="cleanup"; irm https://raw.githubusercontent.com/hellowind777/helloagents/main/install.ps1 | iex
  305. # Uninstall
  306. $env:HELLOAGENTS="gemini"; $env:HELLOAGENTS_ACTION="uninstall"; irm https://raw.githubusercontent.com/hellowind777/helloagents/main/install.ps1 | iex
  307. ```
  308. The shell and PowerShell wrappers now parse `HELLOAGENTS` once, keep plain package install/update behavior when no target is specified, clear lifecycle env before update, branch switching, and uninstall, and then run one explicit sync or cleanup path.
  309. ### Branch switching
  310. `switch-branch` installs the requested npm/GitHub ref first, then syncs host CLIs through npm scripts so it does not depend on the `helloagents` executable during updates:
  311. ```bash
  312. helloagents switch-branch beta
  313. helloagents switch-branch beta claude --global
  314. helloagents branch beta --all --standby
  315. ```
  316. The direct `helloagents switch-branch ...` command also clears stale `HELLOAGENTS*` lifecycle env before its internal npm install and host-sync steps.
  317. Use normal npm commands when you only want to change the package and not sync host CLIs immediately:
  318. ```bash
  319. npm install -g --allow-scripts=helloagents https://github.com/hellowind777/helloagents/archive/refs/heads/beta.tar.gz
  320. npm install -g --allow-scripts=helloagents helloagents@latest
  321. npm explore -g helloagents -- npm run uninstall -- --all
  322. npm uninstall -g helloagents
  323. ```
  324. ### Standby mode files
  325. | CLI | Files written or updated | Cleanup behavior |
  326. |-----|--------------------------|------------------|
  327. | Claude Code | `~/.claude/CLAUDE.md`, `~/.claude/settings.json`, `~/.claude/helloagents -> ~/.helloagents/helloagents` | removes managed marker block, HelloAGENTS hooks/permissions, and symlink |
  328. | Cursor | `~/.cursor/hooks.json`, `~/.cursor/helloagents -> ~/.helloagents/helloagents` | removes managed Cursor hooks and the runtime symlink |
  329. | Gemini CLI | `~/.gemini/GEMINI.md`, `~/.gemini/settings.json`, `~/.gemini/helloagents -> ~/.helloagents/helloagents` | removes managed marker block, HelloAGENTS hooks, and symlink |
  330. | Grok Build | `~/.grok/AGENTS.md`, `~/.grok/hooks/helloagents.json`, `~/.grok/helloagents -> ~/.helloagents/helloagents` | removes managed marker block, managed Grok hooks file, and symlink |
  331. | Codex CLI | `~/.codex/AGENTS.md`, `~/.codex/config.toml`, `~/.codex/hooks.json`, `~/.codex/helloagents -> ~/.helloagents/helloagents`, managed backups | removes managed marker block, managed config keys, managed hooks, symlink, and the latest managed backup |
  332. ### Global mode files
  333. | CLI | Install method | Files involved |
  334. |-----|----------------|----------------|
  335. | Claude Code | native plugin install | `~/.helloagents/host-projections/claude-marketplace`, Claude Code plugin metadata/cache managed by the host |
  336. | Cursor | native local plugin install | `~/.helloagents/host-projections/cursor-local-plugin/helloagents`, materialized into `~/.cursor/plugins/local/helloagents` |
  337. | Gemini CLI | native extension install | `~/.helloagents/host-projections/gemini`, `~/.gemini/extensions/helloagents` |
  338. | Grok Build | native marketplace + plugin install | `~/.helloagents/host-projections/helloagents-grok-marketplace`, `~/.grok/config.toml`, `~/.grok/installed-plugins/registry.json`, Grok plugin cache managed by the host |
  339. | Codex CLI | native local-plugin chain | `~/.agents/plugins/marketplace.json`, `~/plugins/helloagents/ -> ~/.helloagents/helloagents`, `~/.codex/plugins/cache/local-plugins/helloagents/local/ -> ~/.helloagents/helloagents`, `~/.codex/config.toml`, `~/.codex/hooks.json`, `~/.codex/helloagents -> ~/.helloagents/helloagents` |
  340. In global mode, HelloAGENTS now attempts the host-native install commands automatically. Claude Code uses the local marketplace projection, Gemini uses the local extension projection, Grok Build uses the materialized local marketplace projection, Cursor refreshes a real local-plugin copy under `~/.cursor/plugins/local/helloagents`, and Codex keeps linking back to the same stable runtime root, so install, update, branch switching, mode switching, cleanup, and uninstall all refresh against one consistent runtime copy. If a host command is unavailable, run the same commands manually:
  341. ```text
  342. /plugin marketplace add "~/.helloagents/host-projections/claude-marketplace"
  343. /plugin install helloagents@helloagents
  344. gemini extensions link "~/.helloagents/host-projections/gemini"
  345. grok plugin marketplace add "~/.helloagents/host-projections/helloagents-grok-marketplace"
  346. grok plugin install "~/.helloagents/host-projections/helloagents-grok-marketplace/plugins/helloagents" --trust
  347. ```
  348. For Cursor, copy the contents of `~/.helloagents/host-projections/cursor-local-plugin/helloagents` into `~/.cursor/plugins/local/helloagents`. On Windows, do not rely on a symlink or junction that points outside `~/.cursor`.
  349. For Claude Code, the CLI also tries the equivalent `claude plugin marketplace add ...` and `claude plugin install ...` commands. The marketplace is named `helloagents`, and the plugin is also named `helloagents`, so the install target is `helloagents@helloagents`. Restart the host CLI after a global install.
  350. When you switch Claude or Gemini back to standby, HelloAGENTS first removes the native plugin or extension. If that cleanup fails, the host stays tracked as `global` instead of silently stacking standby on top.
  351. Codex global mode is installed by HelloAGENTS automatically through the local-plugin path.
  352. ## Commands in Chat
  353. ### Typical flows
  354. | Goal | Use |
  355. |------|-----|
  356. | Clarify requirements, compare approaches, decide scope & value | `~ask "should this become a full platform or just a thin wedge?"` |
  357. | Let HelloAGENTS choose the path and continue | `~auto "add JWT login"` |
  358. | Review a plan before implementation | `~plan "refactor payment module"` |
  359. | Implement from a clear request or active plan | `~build "finish task 2 in the plan"` |
  360. | Build a full product requirement document | `~prd "modern dashboard for operations team"` |
  361. | Run a long Codex task through `/goal -> ~auto -> ~qa` | `~loop "finish the auth refactor"` |
  362. | Initialize or refresh the project workflow | `~init` |
  363. | Validate current work | `~qa` |
  364. | Generate commit message and sync knowledge | `~commit` |
  365. ### Project initialization vs host global deployment
  366. In standby mode, projects that are not initialized get lighter rules and explicit `~command` entry points. A project becomes initialized after `~init` writes the project-level `<!-- HELLOAGENTS_PROFILE: full -->` marker.
  367. In global mode, HelloAGENTS applies full rules by default at the host level.
  368. ## Project Knowledge Base
  369. ### Local mode
  370. By default, project knowledge lives in the project:
  371. ```text
  372. .helloagents/
  373. ```
  374. This directory is the local knowledge, plan, state, and runtime directory.
  375. ### Repo-shared mode
  376. When `project_store_mode = "repo-shared"`:
  377. - local `.helloagents/` keeps project-local state and runtime files
  378. - stable knowledge and plan files move to `~/.helloagents/projects/<repo-key>/`
  379. - multiple worktrees of the same git repo can share the same stable knowledge
  380. Runtime state and evidence remain local to the working project:
  381. - `state_path`
  382. - `.helloagents/sessions/active.json`
  383. - `.helloagents/sessions/<workspace>/<session>/runtime.json`
  384. - `.helloagents/sessions/<workspace>/<session>/artifacts/*.json`
  385. ### Temporary sessions outside project-local storage
  386. For read-only work with no local output, if neither the current directory nor its parents contain a project-local `.helloagents/` directory, HelloAGENTS keeps short-lived runtime state under the user-level directory:
  387. ```text
  388. ~/.helloagents/runtime/<scope-key>/
  389. ```
  390. This only stores short-lived `STATE.md`, `runtime.json`, and `artifacts/`. Optional `events.jsonl` trace files are only written when trace mode is enabled. It is not project knowledge. Expired transient sessions are removed by TTL cleanup.
  391. Once the task creates or modifies local files, or otherwise leaves local output in the current project, HelloAGENTS creates the project-local `.helloagents/sessions/<workspace>/<session>/STATE.md` automatically instead of keeping that task only in the user-level transient runtime.
  392. ### Knowledge creation rules
  393. | Command or setting | Behavior |
  394. |--------------------|----------|
  395. | `~init` | initializes the project workflow and syncs the knowledge base |
  396. | `kb_create_mode = 0` | disables automatic knowledge updates |
  397. | `kb_create_mode = 1` | syncs knowledge automatically only when the KB already exists |
  398. | `kb_create_mode = 2` | for coding tasks, auto-creates or syncs the KB when it already exists or the project is initialized |
  399. ## Workflow and Delivery
  400. ### Workflow stages
  401. HelloAGENTS uses this stage model for structured work:
  402. ```text
  403. Routing and tiering → Goal clarification → Planning → Implementation → Quality loop → Closeout and archive
  404. ```
  405. | Stage | Purpose |
  406. |-------|---------|
  407. | `Routing and tiering` | decide whether the task should go through `~ask`, `~plan`, `~build`, `~qa`, `~prd`, or automatic flow |
  408. | `Goal clarification` | clarify goal, constraints, and success criteria |
  409. | `Planning` | prepare plan files and choose needed skills |
  410. | `Implementation` | implement and run local checks |
  411. | `Quality loop` | review, run commands, and check contract and evidence |
  412. | `Closeout and archive` | update state, knowledge, and closeout evidence |
  413. HelloAGENTS also keeps an always-on core-rule layer in `bootstrap.md` / `bootstrap-lite.md`.
  414. That layer anchors the agent as a capable executor in a trusted environment, blocks responsibility-shifting to users or other tools, enforces exhausting alternative paths before declaring blockage, corrects proposal bias, distinguishes real external constraints from internal inertia, and keeps user-visible wording in one language unless code identifiers, commands, paths, config keys, or necessary proper names must stay unchanged.
  415. ### Delivery tiers
  416. | Tier | Typical use |
  417. |------|-------------|
  418. | `T0` | read-only analysis, idea exploration, comparison |
  419. | `T1` | low-risk focused fixes or explicit verification |
  420. | `T2` | multi-file features, new projects, structured plans |
  421. | `T3` | high-risk or irreversible work such as auth, payment, database, release, production operations |
  422. ### UI workflow
  423. UI work follows this priority:
  424. 1. current `plan.md` or PRD UI decisions
  425. 2. `.helloagents/DESIGN.md`
  426. 3. any loaded `hello-ui` implementation and validation rules; all UI work must still satisfy the shared UI quality baseline
  427. For heavier UI work, `contract.json` can require:
  428. - `ui.styleAdvisor.required`
  429. - `ui.visualValidation.required`
  430. Those requirements are closed with the current session `artifacts/advisor.json` and `artifacts/visual.json`.
  431. ### Verification sources
  432. Verification commands are detected in this order:
  433. 1. logical `.helloagents/verify.yaml`
  434. 2. package manager scripts such as `package.json`
  435. 3. automatic detection
  436. When `project_store_mode = "repo-shared"`, logical `.helloagents/verify.yaml` resolves from the shared project store.
  437. ## Configuration
  438. Config file:
  439. ```text
  440. ~/.helloagents/helloagents.json
  441. ```
  442. Default shape:
  443. ```json
  444. {
  445. "output_language": "",
  446. "output_format": true,
  447. "notify_level": 0,
  448. "ralph_loop_enabled": true,
  449. "guard_enabled": true,
  450. "kb_create_mode": 1,
  451. "project_store_mode": "local",
  452. "auto_commit_enabled": true,
  453. "commit_attribution": "",
  454. "install_mode": "standby",
  455. "host_install_modes": {}
  456. }
  457. ```
  458. | Key | Default | Meaning |
  459. |-----|---------|---------|
  460. | `output_language` | `""` | follow the user language unless set |
  461. | `output_format` | `true` | direct final-user closeout from the main agent uses the HelloAGENTS layout; intermediate, delegated, and sub-agent output stays natural |
  462. | `notify_level` | `0` | `0` off, `1` desktop, `2` sound, `3` both |
  463. | `ralph_loop_enabled` | `true` | run the QA stop gate for explicit `~qa` / `~loop` or required closeout gates |
  464. | `guard_enabled` | `true` | block dangerous commands |
  465. | `kb_create_mode` | `1` | `0` off, `1` sync existing KB automatically, `2` auto-create or sync the KB for coding tasks |
  466. | `project_store_mode` | `"local"` | `local` or `repo-shared` |
  467. | `auto_commit_enabled` | `true` | auto-create a local commit at closeout when verification passed and the working tree changed; `false` skips only the automatic commit |
  468. | `commit_attribution` | `""` | optional text appended to commit messages |
  469. | `install_mode` | `"standby"` | current default install mode |
  470. | `host_install_modes` | `{}` | managed per-CLI mode map, such as `{ "codex": "standby" }`; recorded only after successful host setup and used before falling back to `install_mode` |
  471. `auto_commit_enabled` is initialized to `true` only when the config file is first created. Later installs and updates only fill missing keys and do not overwrite your existing value.
  472. ## How Each CLI Is Integrated
  473. ### Claude Code
  474. - standby writes `~/.claude/CLAUDE.md`
  475. - standby updates `~/.claude/settings.json` with managed hooks and permissions
  476. - standby creates `~/.claude/helloagents -> ~/.helloagents/helloagents`
  477. - global mode uses Claude Code's plugin system
  478. - switching from global back to standby removes the native plugin first; if that cleanup fails, HelloAGENTS keeps Claude tracked as `global`
  479. ### Gemini CLI
  480. - standby writes `~/.gemini/GEMINI.md`
  481. - standby updates `~/.gemini/settings.json` with managed hooks
  482. - standby creates `~/.gemini/helloagents -> ~/.helloagents/helloagents`
  483. - global mode uses Gemini's extension system
  484. - switching from global back to standby removes the native extension first; if that cleanup fails, HelloAGENTS keeps Gemini tracked as `global`
  485. ### Grok Build
  486. - standby writes `~/.grok/AGENTS.md`
  487. - standby writes a managed global hooks file at `~/.grok/hooks/helloagents.json`
  488. - standby creates `~/.grok/helloagents -> ~/.helloagents/helloagents`
  489. - global mode uses Grok Build's native marketplace plus plugin install path
  490. - global packaging is materialized under `~/.helloagents/host-projections/helloagents-grok-marketplace`
  491. - switching from global back to standby removes the native plugin and marketplace source first; if that cleanup fails, HelloAGENTS keeps Grok tracked as `global`
  492. ### Cursor
  493. - standby updates `~/.cursor/hooks.json`
  494. - standby creates `~/.cursor/helloagents -> ~/.helloagents/helloagents`
  495. - global mode uses Cursor's native local-plugin path
  496. - global packaging is materialized under `~/.helloagents/host-projections/cursor-local-plugin/helloagents`
  497. - the installed local plugin is copied into `~/.cursor/plugins/local/helloagents`, so Cursor does not depend on an external symlink target
  498. - switching from global back to standby removes the local plugin copy first; if that cleanup fails, HelloAGENTS skips standby injection
  499. ### Codex CLI
  500. Codex is rules-file driven by default.
  501. - standby writes `~/.codex/AGENTS.md`
  502. - standby writes a portable managed `model_instructions_file = "~/.codex/AGENTS.md"`
  503. - standby writes a managed and portable `notify = ["helloagents-js", "codex-notify"]` command for closeout notification, so reinstalling, updating, or moving to another machine does not require rewriting an absolute path
  504. - standby writes silent Codex hooks to `~/.codex/hooks.json`
  505. - Codex `SessionStart` stays silent and reads the current `~/.helloagents/helloagents.json` at runtime instead of baking a config snapshot into `config.toml`, so first-turn and post-compaction settings stay current
  506. - install and update also sync HelloAGENTS-managed Codex hook trust state in `~/.codex/config.toml`, so Codex 0.129.0+ does not re-prompt for the managed hooks
  507. - that hook trust state is machine-local generated metadata derived from the current absolute `~/.codex/hooks.json` path; unlike `model_instructions_file = "~/.codex/AGENTS.md"`, it is not portable config and should be regenerated on each machine
  508. - standby creates `~/.codex/helloagents -> ~/.helloagents/helloagents`
  509. - global mode installs the native local-plugin chain, but keeps `~/.helloagents/helloagents` as the single managed runtime source by linking plugin roots, plugin cache, and `~/.codex/helloagents` back to it
  510. - `doctor`, `cleanup`, and `uninstall` also recognize wrapped notify chains such as `--previous-notify ["helloagents-js", "codex-notify"]`, so Codex App / Computer Use wrappers do not cause false drift reports or break notify restoration
  511. - for Codex app/plugin discovery, `global` is the native path; `standby` remains the lighter default for explicit project work
  512. - cleanup removes only the HelloAGENTS-managed hook trust entries, while keeping user-owned hook state untouched
  513. - Codex hooks only synchronize runtime state and enforce Stop gates; they do not inject HelloAGENTS rules or route text through hook output
  514. - Codex closeout de-duplicates Stop hooks and native `codex-notify`, so one turn does not notify twice, and clientless delegated child-completion events stay silent when the managed Stop hook is active
  515. - `/goal` remains Codex-native. Enable it explicitly with `helloagents codex goals enable` when long-running plan execution is needed
  516. - Current OpenAI docs still mark `/goal` as experimental, and Codex app support is still preview. HelloAGENTS therefore treats `/goal` as an opt-in Codex-native accelerator, not as a required runtime dependency
  517. - Goal-aware commands resume from `tasks.md`, `contract.json`, and `state_path`; they do not create goals automatically or mark them complete before HelloAGENTS verification and closeout
  518. ## Verification
  519. Run all tests:
  520. ```bash
  521. npm test
  522. ```
  523. The current suite covers:
  524. - install, update, cleanup, uninstall, branch switching, and mode switching
  525. - stale lifecycle-env protection for direct `switch-branch` and package `preuninstall`
  526. - Windows `.cmd` / `.bat` lifecycle dispatch without Node `DEP0190` warnings
  527. - one-shot shell and PowerShell lifecycle dispatch, plus wrapper env cleanup and mode-routing rules for install, update, cleanup, uninstall, and branch switching
  528. - Claude, Gemini, Grok, Cursor, and Codex host integration behavior, including global-to-standby cleanup and failed native cleanup tracking
  529. - Codex managed `model_instructions_file`, `notify`, `hooks.json`, hook trust state, local plugin, marketplace, and cache behavior
  530. - Codex cleanup and canonical managed notify restoration rules, including wrapped `--previous-notify` chains
  531. - Codex `/goal` feature toggles, long-running route context, and goal-aware command contracts
  532. - `helloagents doctor`
  533. - project storage and `repo-shared` behavior
  534. - workspace-session scoped `state_path`, runtime signals, and evidence
  535. - runtime injection, routing, guard, verification, visual evidence, delivery gates, closeout de-duplication, sub-agent wrapper and notification suppression, and successful-mode tracking after native install failures
  536. - end-to-end host config write, update, cleanup, uninstall, mode-switch, and branch-switch flows across Claude Code, Gemini CLI, Grok Build, Cursor, and Codex CLI
  537. - README and skill contract alignment
  538. ## FAQ
  539. ### What is the role of `docs/`?
  540. `docs/` is reference material for users and AI agents. It may lag behind implementation; runtime behavior is defined by source code, rule templates, skills, templates, and tests.
  541. ### Is this a CLI tool or a prompt framework?
  542. Both.
  543. - `cli.mjs` handles install, update, cleanup, diagnostics, and host config
  544. - rule templates define the loaded workflow rules
  545. - `skills/` defines task-specific behavior
  546. - `scripts/` provides runtime helpers for routing, guard, notify, verification, state, and evidence
  547. ### Should I use `~init` or `--global`?
  548. Use `~init` inside a repo when you want to initialize that project workflow and sync project knowledge.
  549. Use `helloagents --global` when you want host-wide deployment across supported CLIs.
  550. ### What is the difference between standby and global?
  551. `standby` is lighter and explicit. It deploys rules to selected CLIs while leaving each repo uninitialized until you run `~init`.
  552. `global` applies full rules broadly at the host level. Claude, Gemini, and Grok use native plugin, extension, or marketplace installs. Cursor and Codex use native local-plugin paths; Cursor specifically materializes a real plugin copy under `~/.cursor/plugins/local/helloagents`.
  553. If you mainly want Codex app/plugin discoverability, use `global`. If you mainly want a lighter, explicit project workflow, keep `standby`.
  554. ### Do Codex hooks show injected content?
  555. No HelloAGENTS rule or route text is injected through hooks. HelloAGENTS Codex hooks only write runtime state and enforce Stop gates; successful hooks stay quiet, while blocked or failed hooks show the necessary reason.
  556. ### Can I turn off notifications or guard checks?
  557. Yes.
  558. - set `notify_level` to `0` to disable notifications
  559. - set `guard_enabled` to `false` to disable command guards
  560. ### Does `npm uninstall -g helloagents` remove project knowledge?
  561. No. Run `npm explore -g helloagents -- npm run uninstall -- --all` before package removal so HelloAGENTS can reuse the tracked or detected mode for each CLI and clean host integrations plus the stable runtime copy. Project `.helloagents/` files and `~/.helloagents/helloagents.json` are intentionally preserved unless you remove them yourself.
  562. ## Troubleshooting
  563. ### `~help` is not recognized
  564. Check:
  565. ```bash
  566. npm list -g helloagents
  567. helloagents doctor
  568. ```
  569. Then restart the target CLI.
  570. ### A CLI appears installed but behavior is stale
  571. Run:
  572. ```bash
  573. helloagents doctor
  574. helloagents update codex
  575. helloagents --standby
  576. helloagents --global
  577. ```
  578. Use the command that matches your installed mode and target CLI.
  579. ### Codex still uses old files after a local branch switch
  580. Refresh Codex:
  581. ```bash
  582. helloagents update codex
  583. ```
  584. For global mode, you can also run:
  585. ```bash
  586. helloagents --global
  587. ```
  588. ### Notifications do not work
  589. Check `notify_level` first.
  590. - Windows: PowerShell must be able to show desktop notifications or play sound
  591. - macOS: `afplay` should be available
  592. - Linux: install `aplay`, `paplay`, or `notify-send`
  593. ### Guard blocks a command you intended to run
  594. Review the command. Guard blocks known destructive operations and warns about risky writes. If you still want to disable it:
  595. ```json
  596. { "guard_enabled": false }
  597. ```
  598. ## License
  599. Code is licensed under [Apache-2.0](./LICENSE.md). Documentation is licensed under CC BY 4.0.
  600. ## Contributing
  601. - Bug reports: [open an issue](https://github.com/hellowind777/helloagents/issues)
  602. - Feature requests: [open an issue](https://github.com/hellowind777/helloagents/issues)
  603. - Pull requests are welcome
  604. ---
  605. <div align="center">
  606. If this project helps you, a star is the best support.
  607. Thanks to <a href="https://codexzh.com/?ref=EEABC8">codexzh.com</a> / <a href="https://ccodezh.com">ccodezh.com</a> for supporting this project.
  608. </div>

Ratings and comments

Sign in to rate this skill.

Sign in

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