@rpamis/comet

 ██████╗ ██████╗ ███╗   ███╗███████╗████████╗
██╔════╝██╔═══██╗████╗ ████║██╔════╝╚══██╔══╝
██║     ██║   ██║██╔████╔██║█████╗     ██║
██║     ██║   ██║██║╚██╔╝██║██╔══╝     ██║
╚██████╗╚██████╔╝██║ ╚═╝ ██║███████╗   ██║
 ╚═════╝ ╚═════╝ ╚═╝     ╚═╝╚══════╝   ╚═╝

中文版：README-zh.md Bilibili video DouYin

Comet is a resumable long-running task workflow and Skill platform for coding.

It uses a unified cross-platform runtime to connect OpenSpec artifacts, Superpowers execution methodology, Skill creation, evaluation, and release into a closed-loop workflow.

It allows you to use a toolchain to handle everything from requirements to archiving, combine any skill to make it like Comet, evolving your skills based on scientific Rubric, Pass@k, and Pass^k scoring.

[!IMPORTANT] 0.4.0-beta.1 — Comet has been upgraded to a pure Node runtime (no longer dependent on Bash/WSL) and brings three core capabilities: use /comet-any to combine any skill into a custom workflow, use comet eval to evaluate any skill and integrate it into the LangSmith system, and use comet dashboard to visualize each change in the browser.

0.3.9 — Review mode (off|standard|thorough) controls Build/Verify code review with project defaults; init/update now use optional dependency prompts, broader CLI i18n, stronger phase guards, and macOS executable bits.

0.3.8 — Adds Kimi Code support, safe multi-platform comet uninstall, extended subagent dispatch, shared progressive-loading references, update checks, and pre-commit formatting.

0.3.7 — Adds CodeGraph semantic indexing, Beta context compression, active context compression, token optimizations, auto_transition, phase guards, optional TDD, and safer archive/verification flow.

See NEWS.md for details.

Combining OpenSpec and Superpowers is not Comet’s ultimate goal. We hope to track long-running skills like these and find the Harness capabilities that enable stable execution of long-running skills. If you are interested in participating, you are welcome to contribute to our project or learn from our source code.

Why Comet

• The stable core for long-running tasks — Comet’s Classic Spec mode combines OpenSpec and Superpowers with a state machine, phase guards, and scripts that connect the full lifecycle. Agents can only do the work allowed in the current phase and can only exit after the phase work is complete. The core flow can advance automatically, with HITL only at moments that need your confirmation.
• Resumable workflow and intelligent routing — Comet uses intent recognition to route each task toward the path it needs. /comet remembers where a change stopped, supports zero-context recovery across devices, and removes the need to memorize long Skill command names: use /comet to advance or resume your work.
• Skill platform — Comet can author reusable Skill packages and use /comet-any to organize them into distributable Bundles, so Skills you create can be distributed to coding platforms with one command, much like comet init.
• Eval platform — Comet assesses your skills using scientific Rubric, Pass@k, and Pass^k scoring, ensuring skill evolution is based on scientific evidence rather than intuition. It supports integration with LangSmith assessments, bringing evaluation to real-world enterprise production environments. Its dual-agent architecture automates the assessment process in your production environment.

Extremely low memory threshold

With Comet, you only need to remember two skills and one command, covering coding, creation, and evaluation with an extremely low barrier to entry：

• Use /comet for coding tasks
• Use /comet-any to compose any Skills
• Use comet eval to evaluate any Skill

Comet 0.4.0 Baseline Comparison

The following charts are from 16 Comet workflow tasks, with 5 samples per treatment, comparing no Comet, Comet 0.3.9, and Comet 0.4.0.

The core observations were the differences in Pass@5, Pass^5, and Rubric scores. The baseline without Comet Skills only validated business behavior.

From Industry-Frontier Practice

Many Comet capabilities have parallels in current industry practice.

To compare Comet with those patterns, see Comet Docs.

What You Can Learn

• How to reliably trigger nested Skills — not by making an agent perform something that merely looks like a Skill trigger, such as writing files based on a Skill description, but by actually triggering the Skill. Comet invokes many OpenSpec and Superpowers capabilities, with trigger prompts refined through broad real-world practice.
• How to make composed Skills advance through multiple phases automatically — not through manual intervention. Aside from necessary user choices, Comet’s five-phase flow can trigger core Skills automatically while the state machine keeps transitions reliable.
• How to make a Spec lifecycle resumable — Comet links OpenSpec change/spec artifacts with Superpowers design and plan documents, then records phase, execution mode, verification result, and archive status in each change’s .comet.yaml, so an agent can continue after interruption instead of rereading documents and guessing progress.
• How to turn doc synchronization from reminders into automation — Comet scripts handoff, state updates, validation, and archive sync, reducing repeated prompts such as “remember to update the design doc” or “remember to archive the change.”
• How to design guard conditions that agents can execute — phase exits do not rely on an agent saying “done.” Scripts such as comet-guard.mjs, comet-yaml-validate.mjs, and comet-state.mjs check tasks, state fields, verification evidence, and archive conditions before the workflow advances.
• How to distribute and install Skills across platforms — Comet supports many AI coding platforms, project/global install scopes, Chinese/English Skill variants, and platform-specific directories such as Antigravity’s different project/global paths.
• How to turn scripts into agent workflow infrastructure — Comet scripts handle hashes, YAML fields, state machines, and archive flow, showing how workflow control that is easy to scatter across prompts can become testable, reusable tooling.
• How to evolve Skills through scientific evaluation — Comet Eval supports structured rubric scoring plus Pass@k and Pass^k metrics, with both local and LangSmith evaluation paths for production use.
• How to create Comet-like Skills intelligently — /comet-any composes arbitrary Skills. You describe your Skill preferences, and the agent handles stability-related hooks, rules, scripts, and referenced Skill files for you.

Install

Requirements:

• Node.js 20+
• npm/npx
• Git

npm install -g @rpamis/comet

Quick Start

cd your-project
comet init

Support for OpenClaw and Hermes, and other AI platforms

For platforms that use the generic skills CLI directly, you can install the Comet skill package with:

npx skills add rpamis/comet

Screenshots

Classic Spec Skill

Auto-install OpenSpec & Superpowers, one-click dev environment setup Multi-phase Skill entry, auto-detects current Spec stage, auto-triggers core flow, manual review at key nodes

Integration with LangSmith/LangFuse

Comet Eval’s automated dual-agent architecture can integrate online with LangSmith/LangFuse environments, making experiments traceable and skills evolvable.

Manage your Skill baseline in LangSmith and view detailed performance metrics, latency, and token consumption

Trace your Claude Code in LangSmith

Trace custom Rubric metrics with Pytest in LangSmith

Commands

Supported Platforms

comet init supports 33 AI coding platforms:

Skills

After comet init, three groups of skills are installed to the selected platform’s skills/ directory:

Comet Skills

Guard & Automation Scripts

Workflow

/comet
  ↓ auto-detect
/comet-open  -->  /comet-design  -->  /comet-build  -->  /comet-verify  -->  /comet-archive
(OpenSpec)         (Superpowers)       (Superpowers)       (Both)           (OpenSpec)

/comet-hotfix (preset path, skips brainstorming)
  open  -->  build  -->  verify  -->  archive

/comet-tweak (lightweight preset, chains OpenSpec)
  open  -->  build  -->  verify  -->  archive

Five Phases

State Management

Comet uses a decoupled state architecture with separate files

Reliability Features

Comet ensures agent execution reliability through automated state transitions:

Classic Spec Mode Project Structure

your-project/
├── .comet/
│   └── config.yaml              # Project-level global config (context_compression, review_mode, auto_transition)
├── .claude/skills/              # Platform skills dir (Comet + OpenSpec + Superpowers)
│   ├── comet/SKILL.md
│   │   └── scripts/
│   │       ├── comet-guard.mjs       # Phase transition guard (--apply auto-updates state)
│   │       ├── comet-env.mjs         # Script discovery helper
│   │       ├── comet-handoff.mjs     # Design handoff (OpenSpec → Superpowers context tracing)
│   │       ├── comet-archive.mjs     # One-command archive automation
│   │       ├── comet-yaml-validate.mjs # Schema validator
│   │       ├── comet-hook-guard.mjs   # Phase write guard (PreToolUse hook)
│   │       └── comet-state.mjs       # Unified state management (init/set/get/check/scale)
│   ├── comet-*/SKILL.md
│   ├── openspec-*/SKILL.md
│   └── brainstorming/SKILL.md
├── openspec/                    # OpenSpec — WHAT
│   ├── config.yaml
│   └── changes/
│       └── /
│           ├── .openspec.yaml       # OpenSpec state
│           ├── .comet.yaml          # Comet workflow state (Classic fields + run_id link)
│           ├── .comet/
│           │   ├── run-state.json   # Engine Run state (machine-owned, auto-migrated)
│           │   └── state-events.jsonl # State transition audit log (append-only)
│           ├── proposal.md
│           ├── design.md
│           ├── specs//spec.md
│           └── tasks.md
└── docs/superpowers/            # Superpowers — HOW
    ├── specs/                   # Design documents
    └── plans/                   # Implementation plans

Development

See CONTRIBUTING.md | 中文版 for development setup, commit conventions, PR process, branch workflow, and guidance for adding platforms, skills, scripts, or changelog entries.

See CHANGELOG.md for version history and updates.

Roadmap

Track our development progress and upcoming features on the Comet Roadmap.

Star History

Contributors

License

MIT

Community

Reference

LINUX DO - 新的理想型社区