ClawSpec — Summary

ClawSpec is an OpenClaw plugin that embeds an OpenSpec workflow directly into chat with a split control surface: /clawspec ... slash commands for deterministic workspace/project/state management, and cs-* chat keywords (cs-plan, cs-work, cs-pause) that inject workflow context into the active conversation. Planning runs visibly in the main chat turn (cs-plan), while implementation runs in a durable background worker via ACP (Agent Control Protocol) that survives gateway restarts (cs-work). The plugin manages one unfinished change per repo across channels, maintains a planning journal of requirement discussions, uses file-backed progress/result state for crash recovery, and can restore tracked files from snapshots rather than doing blanket git resets on cancel. ClawSpec is the most architecturally sophisticated plugin in this batch: six runtime layers, an AcpWorkerClient for background execution, a watcher manager with restart-backoff, and explicit durability guarantees.

differs_from_seeds: ClawSpec is the only framework in this batch that targets OpenClaw (a chat-centric AI platform), making it analogous to claude-flow in architecture (multi-layer orchestration, background workers, durable state) but implemented as a chat plugin rather than a CLI tool. The ACP-based durable background execution with gateway-restart survival has no equivalent in any seed framework.

ClawSpec — Overview

Origin

Published by bytegh, v1.0.21, no license specified. Targets OpenClaw platform with ACP (Agent Control Protocol) for background execution. Node.js >= 24.0.0 required. Last commit 2026-03-29.

Philosophy

From the README: "ClawSpec is an OpenClaw plugin that embeds an OpenSpec workflow directly into chat. It splits project control and execution on purpose."

The design philosophy is visible planning + durable background execution:

• Planning is visible: cs-plan runs in the main chat turn
• Implementation is durable: cs-work hands off to a background worker that survives gateway restarts
• Worker transport is direct: ClawSpec talks to acpx through its own AcpWorkerClient
• Progress is file-backed: worker writes progress/result files so the watcher can recover after gateway restarts
• Repo safety is explicit: cancel uses snapshot restore for tracked files instead of blanket repository reset

Manifesto-style statements

• "Planning is visible. cs-plan runs in the main chat turn and does not use a hidden subagent."
• "Implementation is durable. cs-work is handed off to a watcher-managed background worker."
• "Repo safety is explicit. Cancel uses snapshot restore for tracked files instead of blanket repository reset."
• "One unfinished change is enforced per repo across channels."

Target user

Teams using OpenClaw for AI-assisted development who want to integrate an OpenSpec-style spec-driven workflow into their chat-native workflow without breaking the chat-as-primary-UX model.

LINUX.DO badge

The README references LINUX.DO (a Chinese developer community), suggesting a primarily Chinese developer audience.

ClawSpec — Architecture

Distribution

• npm package: clawspec (v1.0.21)
• Plugin API: OpenClaw pluginApi >= 2026.3.24
• openclaw.plugin.json manifest defines configuration schema and UI hints

Install method

Add to OpenClaw plugin configuration (analogous to opencode-plugin-openspec):

{ "plugins": ["clawspec"] }

Tech stack

• Language: TypeScript (Node.js ≥24.0.0, ESM)
• Plugin entry: index.ts (OpenClaw plugin API)
• Background execution: AcpWorkerClient → acpx CLI (ACP session manager)
• Build/test: Node.js --experimental-strip-types

Runtime layers (from README)

Directory structure

clawspec/
├── index.ts            # Plugin entry
├── src/
│   ├── acp/            # ACP client
│   ├── bootstrap/      # Dependency initialization
│   ├── config.ts
│   ├── control/        # /clawspec command routing
│   ├── dependencies/   # ensureOpenSpecCli, ensureAcpxCli
│   ├── execution/      # ExecutionWatcher, execution-control.json
│   ├── memory/         # Project memory store
│   ├── openspec/       # OpenSpec CLI client
│   ├── orchestrator/   # Main orchestration
│   ├── planning/       # Planning journal, cs-plan
│   ├── rollback/       # Snapshot-based cancel/restore
│   ├── state/          # Plugin state store
│   ├── types.ts
│   ├── utils/
│   ├── watchers/       # WatcherManager
│   ├── worker/         # AcpWorkerClient, worker-io-helper
│   └── workspace/      # Workspace store
├── skills/
│   ├── openspec-propose.md
│   ├── openspec-explore.md
│   └── openspec-apply-change.md
├── openclaw.plugin.json
└── package.json

Required runtime

• Node.js >= 24.0.0
• OpenClaw >= 2026.3.24 plugin API
• openspec CLI (auto-installed at bootstrap)
• acpx CLI (auto-installed at bootstrap)

ClawSpec — Components

Slash commands (/clawspec ...)

Chat keywords (inject workflow context)

Plugin hooks (OpenClaw lifecycle)

Skills (used in cs-plan injection)

State stores

ClawSpec — Uniqueness & Positioning

differs_from_seeds

ClawSpec is the only plugin in this batch targeting OpenClaw (a chat-native AI platform). Its architectural sophistication exceeds all seeds except claude-flow: six runtime layers, durable background execution via ACP, file-backed worker progress/result state, gateway-restart-survivable workers, and snapshot-based cancel/restore. Unlike claude-flow (which is a CLI orchestrator), ClawSpec is chat-native and keeps planning visible in the main turn. The planning journal (accumulated requirement discussions injected into subsequent planning turns) is a unique context-building mechanism not present in any seed. The "one unfinished change per repo" invariant enforced across channels is a governance constraint no seed implements.

Positioning

• Category: OpenClaw plugin — OpenSpec workflow orchestration with durable background execution
• User: Teams using OpenClaw who want OpenSpec-style spec-driven development with background implementation that survives network disruptions
• Integration: Deep — hooks into OpenClaw's message_received, before_prompt_build, agent_end, and bootstrap lifecycle events
• Value: Durable background execution + visible planning + accumulated planning journal + snapshot-safe cancel

Observable failure modes

1. Node.js ≥24.0.0 requirement: Cutting edge — many servers/environments won't have Node 24 available
2. acpx dependency: External CLI dependency that must be available; bootstrap failure blocks the entire plugin
3. One-change-per-repo invariant: Teams working on multiple parallel changes must use multiple repos or channels
4. Deprecated config fields: Several no-op fields retained for backward compatibility — could confuse users
5. JSONL accumulation: Planning journal has no size limit — long sessions may inflate context injection
6. OpenClaw-specific: Zero portability to Claude Code, Cursor, or other tools

Cross-references

• Depends on: OpenClaw platform, OpenSpec CLI, acpx CLI
• Architecturally analogous to: claude-flow (multi-layer orchestration + background workers) but chat-native
• Compared to: opcode-plugin-openspec (this batch) — similar chat-plugin pattern but ClawSpec is far more complex