By splockorg
A governed plan -> implement -> verify lifecycle framework for Claude Code: deterministic enforcement spine (sealed-state hooks, intent/collision registry, Ralph completion gate) over a two-call planner, slash-command workflow, and subagent roster. Anthropic-native.
Code one orchestrator task — spawn coder subagent against <slug>_orchestrator.json::tasks[<task-id>] (auto-picks next-ready task when task-id omitted; optional operator directive after `--`)
Autonomously develop a multi-phase plan doc by spawning implementer + evaluator agents per phase with no human gates between phases
Plainspeak briefing of the last substantive assistant message (or a slug artifact) — translation, not review; optional paste-able decision sheet
Implplan a splock slug — promotes plan substrate to orchestrator substrate via two-call planner
Plan a splock slug via the two-call planner — Call 1 free-form reasoning + Call 2 schema-valid JSON emission
coder for per-task code work under the §A Ralph completion gate, executing the file_paths_touched + tests_enabled contract of a single orchestrator task
eli5 for plainspeak translation of existing material (a conversation excerpt or slug artifact) into a deterministically-formatted briefing — finds nothing new, drops no caveats
planner for the two-call planning surface — Call 1 reasoning (free-form MD), Call 2 emission (schema-valid JSON); both calls are made by the driver, not by this subagent's prose
qa for adversarial review of an existing <slug>_recon.md, emitting a structured question-list against a deterministically-constructed rubric
qna for operator-question investigation, returning a structured answer + supporting evidence against the slug's repo context
Execute one orchestrator task under the Ralph completion gate — spawn the coder subagent against <slug>_orchestrator.json tasks[<task-id>] (auto-picks the next-ready task when task-id omitted). Use when the user says "code X", "implement task T-N", "run the next task", "/code X", or to drive the implement+verify loop after /implplan. Writes code, runs tests via bin/verify, refuses completion until the verifier answers READY.
Autonomously execute a multi-phase plan document by spawning implementer + evaluator agents per phase with no human gates between phases. Use when the user says "develop-plan <path>", "run the whole plan autonomously", or wants a markdown plan driven to completion phase-by-phase without per-phase stops. Long-running and autonomous; prefer the gated /code loop when human checkpoints are wanted.
Promote a plan substrate into an executable orchestrator substrate (tasks DAG, junctions, per-task test wiring) via the two-call planner. Use when the user says "implplan X", "turn the plan into tasks", "build the orchestrator for X", or after /plan when a slug is ready to be decomposed into ordered, dependency-gated tasks. Emits <slug>_orchestrator.json and renders the .md twin.
Run a phase-boundary review gate (plan_to_implplan or implplan_to_code) via bin/verify. Use when the user says "review the phase boundary", "run the review gate for X", or when an orchestrator junction of kind review_gate must be cleared before the DAG advances to the next phase.
Author a structured plan for a slug via the two-call planner (Call 1 free-form reasoning, Call 2 schema-valid JSON emission). Use when the user says "plan X", "write a plan for X", "design the approach to X", or after recon when an initiative needs success criteria + a task skeleton. Emits <slug>_plan.json and renders the <slug>_plan.md twin.
Executes bash commands
Hook triggers when Bash tool is used
Modifies files
Hook triggers on file write and edit operations
Uses power tools
Based on adoption, maintenance, documentation, and repository signals. Not a security audit or endorsement.
Executables (bin/) — files in this plugin's bin/directory are added to the Bash tool's PATH while the plugin is enabled.
Uses Bash, Write, or Edit tools
Uses Bash, Write, or Edit tools
A governed plan → implement → verify lifecycle for Claude Code, with a deterministic enforcement spine.
splock is an Anthropic Claude Code plugin. It turns ad-hoc agent work into a structured, reviewable lifecycle: you plan an initiative into an explicit specification, implement it task by task, and verify each task against a completion gate that an executing agent cannot talk its way past. The parts of the system that matter for correctness and safety live in deterministic code — shell hooks and CLI exit codes — not in prose an agent could ignore or a hostile input could overwrite.
A capable coding agent left to free-form on a real codebase tends to: skip the plan, drift from scope, edit files outside its lane, declare success without running tests, and quietly weaken the very guardrails meant to stop it. Prompts that say "please run the tests" or "do not touch sealed files" are advisory — an agent can rationalize past them, and adversarial content the agent merely reads can instruct it to.
splock's answer is to move every load-bearing decision out of the model:
PreToolUse hooks that
return a non-zero exit code. Enforcement never depends on agent prose.The result is a workflow you can hand to an autonomous or semi-autonomous agent and still reason about what it is structurally prevented from doing.
splock ships a set of slash commands and the subagents and skills behind them:
| Stage | Command | What it does |
|---|---|---|
| Reconnaissance | /recon | Survey the codebase / problem space before committing to a plan. |
| Research | /research | Deeper external/internal investigation feeding a plan. |
| Q&A | /qna | Capture an interactive Q&A log that a plan can ingest. |
| Plan | /plan | Two-call planner → schema-valid plan substrate + Markdown twin. |
| Implementation plan | /implplan | Expand a plan into an orchestrator DAG of tasks with dependencies. |
| Code | /code | Execute a task under the completion gate (write code, run tests, iterate). |
| Test | /test | Run the enabled test set across the plan / at a phase gate. |
| Review | /review | Sonnet-class review at phase boundaries. |
| QA | /qa | Adversarial review of a plan or an implementation. |
| Wrap | /wrap | Fold an exploratory artifact into the plan record. |
The two-call planner separates free-form reasoning (call 1) from constrained, schema-valid JSON emission (call 2). The completion gate ("Ralph gate") runs the coder in a retry loop and refuses to declare a task done until an independent verifier confirms a green test run.
Projects running many slugs at once can opt into fleet — a
concurrency-safe lifecycle tracker with a generated status hub. State
lives in per-slug files (docs/plans/<slug>/_fleet.json + an
append-only event log), so any number of agents update concurrently
with zero write contention; the hub .md's FLEET:* zones are a
derived view regenerated by bin/fleet render --write. Stage commands
and engines record wip on start and ready --next <next stage> (or
done / blocked / closed) on completion automatically — agents
never hand-edit the hub, and the per-slug state files are sealed so
they can't. Opt in with bin/fleet init; convert an existing
hand-edited launcher with bin/fleet init --hub + migrate + seed.
npx claudepluginhub splockorg/splock --plugin splockHarness-native ECC plugin for engineering teams - 67 agents, 279 skills, 94 legacy command shims, reusable hooks, rules, MCP conventions, and operator workflows for Claude Code plus adjacent agent harnesses
v9.54.1 — Reliability wave: tangle contextual review correction loop with hard round ceiling, progress-supervised review rounds (per-agent stall watch, descendant-tree kills), council diversity and agy pin fixes, marketplace generator source-of-truth fix, provider troubleshooting runbook and cost-expectations docs. Run /octo:setup.
Claude harness - A harness for solo developers (Vibecoders) to handle full-cycle contract development.
Evidence-gated AI coding workflow: scan → analyze → plan → TDD → execute → fix → verify → review, powered by Codebase Memory MCP >= 0.9.0 with optional Serena LSP intelligence. Includes blast-radius planning, test/cycle gates, independent review, and Windows Git Bash hook auto-resolution.
Persistent file-based planning for AI coding agents. Crash-proof markdown plans (task_plan.md, findings.md, progress.md) that survive context loss and /clear, with an opt-in completion gate and multi-agent shared state. Manus-style. Works with Claude Code, Codex CLI, Cursor, Kiro, OpenCode and 60+ agents via the SKILL.md standard. Includes Arabic, German, Spanish, and Chinese (Simplified and Traditional).
Core skills library for Claude Code: TDD, debugging, collaboration patterns, and proven techniques
Own this plugin?
Verify ownership to unlock analytics, metadata editing, and a verified badge. GitHub access is read-only (username + org membership).
Sign in to claimOwn this plugin?
Verify ownership to unlock analytics, metadata editing, and a verified badge. GitHub access is read-only (username + org membership).
Sign in to claim