bootstrap

A risk-scaled delivery workflow for Claude Code, Codex, and OpenCode:

/team-plan → /team-build → /team-review → /team-ship

The workflow uses the smallest mechanism that satisfies the real requirements and failure boundaries. A four-file mechanical change should stay small; a one-file credential or destructive migration still receives security, rollback, and verification depth. Complexity must be justified by scale, repetition, concurrency, security, or failure impact—not by a fixed ceremony.

Plugins

Runtime	Plugin	Version	What it provides
Claude Code	bootstrap-workflow	5.10.0	The seven team-* skills and the safety gates
Codex / OpenCode	bootstrap-workflow-agents	2.10.0	The same, runtime-neutral
Claude Code / Codex / OpenCode	bootstrap-orchestrate	3.0.0	/orchestrate, an invoke-only skill, plus the five effort shims it dispatches to
Claude Code / Codex	wwbd	1.3.0	Boris Cherny-inspired engineering-judgment advisory skill
Claude Code / Codex	wwed	1.0.0	Musk's five-step algorithm as a subtraction and cycle-time advisory skill; pairs with wwbd
Claude Code / Codex	analytics-verify	1.2.4	Claim ledger, check script and independent-verifier loop for analytics and research deliverables, with an always-on nudge
Claude Code / Codex	test-audit	1.0.0	Authoring gate and evidence-first audit workflow for tests, with an always-on nudge; adapted from OpenClaw (MIT)
Claude Code / Codex / OpenCode	comment-rule	2.0.0	One comment checker for CI, merge gates and write-time feedback: no file:line or PR/issue/ticket history in comments; every new comment line listed for a reviewer to judge
Claude Code / Codex / NanoClaw	concise	1.0.1	Session-only concise, grammatical chat mode
Claude Code / Codex / NanoClaw	slack-humanizer	1.0.1	Slack messages drafted in the user's voice and posted as rich text, so lists render as real Slack lists

Delegation is invoke-only

Automatic delegation pressure is off. Working directly is the normal mode: nothing tells a session to reach for a sub-agent, and nothing gates a session that reads source, runs a check, or implements a fix itself.

bootstrap-orchestrate adds no standing delegation directive or dispatch-first gate. Its hooks only route omitted model/effort fields and validate explicit Codex context; the Codex SessionStart entry is a one-line reminder for the opt-in picker. Invoke the skill when you want one sub-agent to do all the work in a single thread — /orchestrate opus high <task>, or "use an opus subagent at high effort to …".

Two mechanisms used to create the pressure, and both were deleted rather than moved: the standing SessionStart directive that told every session to load the skill, and the dispatch-first PreToolUse guard, which warned and then BLOCKED a coordinator that read implementation source or ran a check before dispatching.

The team-* skills still delegate when you invoke one — the shared workflow contract they load says to hand substantive work to a sub-agent and keep it for the whole task. That is deliberate: /team-build is an explicit request for the delegated workflow. What is gone is the automatic pressure, not delegation itself.

What /orchestrate is

A parameterized delegation prompt, and nothing else.

/orchestrate <model> <effort> <task>

The first two words are the model and the effort when they look like one; everything after is the task. Leave either out and a confident usable Jev route may fill it. When Jev is unavailable, abstains, or returns no usable route, the workflow adds no override: the coordinator may make its normal task-based choice, or leave the field omitted for the runtime's native inheritance and configuration. It dispatches ONE sub-agent, hands it the brief, and keeps that same sub-agent for every later round.

Parameter	Meaning	Default
{model}	the sub-agent's model, as this runtime names it	confident picker route, normal coordinator choice, or native inheritance
{effort_level}	the effort the sub-agent runs at	confident picker route, deliberate coordinator choice, or native configuration
{rounds}	coordinate→delegate cycles before stopping	3
{done}	the completion signal	the deliverable is complete with acceptance evidence

The task text can override the last two: "stop after 5 rounds", "until the numbers reconcile".

The retained owner implements, tests and repairs in one session. The coordinator selects the deliverable's check before dispatch and verifies the reported artifact, command, result and limitations. An explicit user choice of check or verification owner takes precedence. Independent review, when required, uses a separate reviewer with fresh context; owner testing does not establish independence. New bounded Codex workers use fork_turns: "none" with a self-contained brief; followups resume the same worker through build, test and repair.

There is no role behind it, no approved model floor, no helper CLI, and no cross-provider hop: a Claude session dispatches Anthropic models and a Codex session dispatches OpenAI models, because that is what each runtime's own tool accepts — ask for the other and the tool rejects it, which is the report. Dispatch goes through whatever the runtime already has:

Runtime	Route	Caveat
Claude Code	Agent tool, bootstrap-orchestrate:worker-<level>, then SendMessage each round	family alias only (fable/opus/sonnet/haiku); no specific version
Codex	spawn_agent with model + reasoning_effort + fork_turns: "none", then the same agent id each round
OpenCode	task tool, agent worker-<level> if present, else the default sub-agent	nothing installs the shims on a bare OpenCode host, so effort may not be settable

The two caveats are the two places a runtime would degrade silently: the Agent tool takes only a family alias, so /orchestrate claude-opus-5 … gets opus and is told so; and OpenCode runs a default sub-agent when the shim is absent, and says so. Each of those sentences is gated by its own drift token and a mutation test.

On the last row: nothing in this repo installs the effort shims onto an OpenCode host — a Codex-shaped manifest cannot ship agents, and OpenCode would not read model: inherit or effort from one anyway. The skill therefore degrades out loud rather than pinning an effort it cannot pin.

Picker abstention or failure does not choose a model or effort. Output records decision: "inherit", pick: null, and provenance: "native" so a raw low-confidence suggestion cannot be mistaken for an effective route. Existing explicit choices stay intact subject to the existing compatibility caps; a coordinator may still deliberately select a normal model, role, or effort shim from the task. Fields it leaves omitted follow the client's native inheritance and configuration rather than a workflow-owned fallback.

A named role is never rewritten. Claude Code gives a per-call model precedence over a role's own model frontmatter, inherit included, and a role's effective definition can live where a hook cannot read it (managed settings, --agents). So the spawn hook fills model and effort only for a roleless spawn (general-purpose or no type) or an effort shim; any other subagent_type — built-ins such as Explore, project/user custom roles, plugin roles — keeps its installed model and costs no picker call. To route a named role, name its model in the call.

On the Codex row: spawn_agent accepts model and reasoning_effort (SpawnAgentArgs, codex-rs 0.154.0, core/src/tools/handlers/multi_agents/spawn.rs:229-230), exposed by default (multi_agent_v2.expose_spawn_agent_model_overrides, core/src/config/mod.rs:1308).

The one thing the plugin ships besides the skill is five near-empty agent definitions, agents/worker-<level>.md. They exist because Claude Code's Agent tool takes a model per call but not an effort — effort can only be pinned in an agent definition's frontmatter. So each shim pins one level, sets model: inherit so the dispatch still chooses the model, and carries a single line of body. They are not roles, and the drift gates assert exactly that: five files, model: inherit, and a body too short to hold a contract.

scripts/plugin-enablement.mjs prints the composed session for any plugin set, and scripts/plugin-enablement.test.mjs resolves and RUNS the hooks each state registers, asserting that enabling bootstrap-orchestrate adds no directive and no gate:

node scripts/plugin-enablement.mjs bootstrap-workflow                        # disabled
node scripts/plugin-enablement.mjs bootstrap-workflow bootstrap-orchestrate  # enabled

The workflow plugins expose the seven team skills; /orchestrate ships beside them in its own plugin:

Skill	Purpose
/team-plan	First planning entry point; writes the normative plan.md and runs its independent review
/team-build	Implements the approved plan with proportional testing and delegation
/team-review	Reviews a plan or implementation, verifies findings, and records evidence
/team-auto	Runs approved plan → build → review, then hands off to /team-ship
/team-debug	Diagnoses root cause from evidence before changing production code
/team-ship	Merges on readiness and posts an FYI; holds for a human only on the scheduled release and genuine decisions
/team-retro	Finds repeat mistakes in a delivery, session or time window and ranks how to make each impossible

/team-plan absorbs requirements, constraints, architecture, acceptance criteria, and execution decomposition. /team-review selects QA, drift, security, performance, best-practice, and domain lenses only when the actual risk warrants them. A finding becomes MUST-FIX only after the lead traces it to a violated invariant or concrete failure mode.

/team-auto shares a maximum of 3 corrective rounds across build/test/review, with one reconsideration on repeated failure signatures. No progress or repeated workflow-created obstruction stops the run; a second productive failure alone does not. It hands off to /team-ship, which merges on readiness with an FYI and holds only on its second tier (scheduled production release, irreversible data, credentials, external publishing, spend, direction).

Workflow artifacts

Substantial work uses two minimal durable artifacts; simple tasks can report evidence in chat:

• docs/specs/<feature>/plan.md — the approved product, design, and execution contract.
• docs/specs/<feature>/run.md — current stage, verified findings, actual reviewer/model details, and verification evidence valid for the exact artifact, environment and command.

docs/specs/<feature>/.team-auto-active is an ephemeral concurrency sentinel, not another review document. It is removed on normal exit and recovered after two hours without refresh.

Cross-model review

Independent other-family review is mandatory at both consequential gates:

1. /team-plan reviews the raw proposed plan before consequential implementation.
2. /team-review --implementation reviews the approved plan plus raw implementation diff.

Routine work does not automatically need both gates; explicit requested reviews are honored. Choose the other family relative to the artifact author, not the coordinator. The review receives source artifacts, not the lead model's conclusions, and is non-mutating. Findings are hypotheses until verified by the lead. The plugin explicitly selects reviewer effort and ignores host and container Codex configuration; the Codex reviewer model is Codex's own current default, recorded from the run header.

Claude-authored artifact reviews use (high default, explicit validated overrides allowed):

codex exec \
  --ignore-user-config \
  -c 'model_reasoning_effort="high"' \
  --ephemeral \
  --yolo

Codex-authored artifact reviews use:

claude -p \
  --model opus \
  --effort high \
  --safe-mode \
  --no-session-persistence \
  --permission-mode plan \
  --tools "" \
  --strict-mcp-config \
  --output-format json

Each external reviewer runs in the foreground with a 60-minute process ceiling. For Codex, --yolo avoids the inner sandbox that cannot create namespaces inside nested Docker; the NanoClaw container is the external isolation boundary, while the review contract remains non-mutating and supplies its source bundle on stdin. Missing or unauthenticated CLIs, unsupported flags, timeouts, non-zero exits, and malformed or empty output are recorded distinctly in run.md. The workflow does not retry automatically or call a same-family pass “diverse.” Manual work asks the user whether to proceed with degraded coverage; /team-auto stops once.

Delegating work

The team-* skills hand substantive work — design, implementation, research, debugging, judgment-heavy review — to a sub-agent, and keep that same sub-agent for the whole task. Independent review still starts in a fresh context, because a reviewer is chosen for independence from the artifact's author.

There is no approved model floor and no named worker role. Pick the model and the effort at dispatch from the task shape, record what you actually picked, and retain it for that sub-agent's build/test/fix loop. shared/workflow-contract.md carries the effort rubric: low for mechanical work, the dispatched default for bounded implementation, high for debugging without a known root cause or a trust-boundary change, xhigh when high did not resolve it, max only on evidence that xhigh was insufficient.

The previous release pinned all of this to one hand-edited JSON policy file in the workflow plugin. It rendered a named worker agent definition, a Codex role TOML, a SessionStart installer that copied the TOML into the user's Codex home, and a Node CLI transport mirrored into four plugins. Every piece of that is deleted. Naming a model and an effort at dispatch is the thing the policy existed to decide, and the runtime's own sub-agent tool is the transport. Upgrading needs no cleanup on your side: the role only ever reached a Codex home through that installer, and node scripts/retire-bootstrap-agents.mjs removes marker-owned leftovers, and worker-frontier is on its list — a home the old installer wrote to keeps that file otherwise, still pinned to the old model and still offered as an agent type.

Record saved defaults, requested settings and actual runtime metadata separately: a saved setting does not prove what the session ran at. Existing conversational approval survives factual and test-detail plan refinements; new product, scope, trust and destructive boundaries keep their gates. Reuse evidence only for the unchanged artifact, environment and command, and invalidate it after relevant changes.

Install

Claude Code

/plugin marketplace add davekim917/bootstrap
/plugin install bootstrap-workflow@davekim917-bootstrap
/plugin install bootstrap-orchestrate@davekim917-bootstrap
/plugin install wwbd@davekim917-bootstrap
/plugin install wwed@davekim917-bootstrap
/plugin install analytics-verify@davekim917-bootstrap
/plugin install test-audit@davekim917-bootstrap
/plugin install comment-rule@davekim917-bootstrap
/plugin install concise@davekim917-bootstrap
/plugin install slack-humanizer@davekim917-bootstrap

Codex

codex plugin marketplace add davekim917/bootstrap --ref main
codex plugin add bootstrap-workflow-agents@davekim917-bootstrap
codex plugin add bootstrap-orchestrate@davekim917-bootstrap
codex plugin add wwbd@davekim917-bootstrap
codex plugin add wwed@davekim917-bootstrap
codex plugin add analytics-verify@davekim917-bootstrap
codex plugin add test-audit@davekim917-bootstrap
codex plugin add comment-rule@davekim917-bootstrap
codex plugin add concise@davekim917-bootstrap
codex plugin add slack-humanizer@davekim917-bootstrap

For a local checkout at ~/plugins/bootstrap:

codex plugin marketplace add ~/plugins/bootstrap
codex plugin add bootstrap-workflow-agents@davekim917-bootstrap
codex plugin add bootstrap-orchestrate@davekim917-bootstrap
codex plugin add wwbd@davekim917-bootstrap
codex plugin add wwed@davekim917-bootstrap
codex plugin add analytics-verify@davekim917-bootstrap
codex plugin add test-audit@davekim917-bootstrap
codex plugin add comment-rule@davekim917-bootstrap

Codex loads the plugin from its cache through .codex-plugin/plugin.json; do not copy workflow skills or agent definitions into a user home.

codex plugin add is what writes the [plugins."<name>@davekim917-bootstrap"] stanza with enabled = true into ~/.codex/config.toml. Enablement is per plugin and opt-in, so an existing Codex install does not pick up bootstrap-orchestrate when the marketplace gains it — run the add above (or add the stanza by hand) once per host.

Reaching NanoClaw containers

Container Claude agents need no NanoClaw change. discoverPlugins walks ~/plugins three levels deep for a .claude-plugin/plugin.json and hands each hit to the SDK as a plugins: entry, which is what loads a plugin's declared hooks; plugins/bootstrap/plugins/wwbd matches at the third level. For both Claude and Codex mappings, the shared picker keeps a container's inherited, scoped native HTTPS proxy and never replaces it with the host's default OneCLI agent. Only a plain host picker with neither inherited proxy nor direct authentication uses that existing OneCLI agent for the fixed TypeSafe request. A container whose scoped route is missing gets an unavailable pick; it cannot borrow the host identity. The guard recognizes Docker/Podman marker files and NanoClaw's existing per-spawn NANOCLAW_ASSISTANT_NAME environment marker. Neither plugin ships a nanoclaw-plugin.json, and neither should: that file's preToolUseGuards is a de-duplication signal telling NanoClaw to stand down one of its OWN built-in gates, and bash-email is the only value anything consumes. check-plugin-boundaries fails if one appears in the orchestrate plugin.

WWBD is installed separately from the workflow plugin. After installing it, start a new Codex session so its WWBD skill is available. Verify installation with codex plugin list. Both runtimes get the same SessionStart reminder from the plugin's own hook; Codex additionally discovers the advisory skill through its native plugin skill loader.

WWBD and WWED are the only plugins here that ship a standing directive, and they show how one is delivered: the runtime's own plugin declares a SessionStart command hook that cats the always-on.md in its own plugin root, and the hook's stdout is injected into the model's context. Claude's hooks/wwbd-hooks.json resolves ${CLAUDE_PLUGIN_ROOT}; the Codex manifest declares a second file, hooks/wwbd-codex-hooks.json, resolving ${PLUGIN_ROOT} — Codex does not expand the Claude token. Nothing outside a plugin delivers a directive, so disabling the plugin removes it on every runtime at once. Adding a hook to a plugin that had none means Codex asks once to trust that plugin's hooks on the next session start.

Comment rule

comment-rule is the one place the comment rule lives. A comment belongs in code when, without it, a reader (human or agent) would get something wrong: an external system's quirk, why the obvious approach is wrong. Only a reviewer can judge that, so the checker blocks only the mechanical forms, a comment that cites file:line or a PR/issue/ticket number, and lists every new comment line for the reviewer to keep or cut. Comment growth is reported, never failed. CI jobs, merge gates and the write-time hook all call the same checker:

node plugins/comment-rule/bin/comment-rule.mjs check --repo <repo> [--base <ref>] [--head <ref>] [--own-typescript] [--json]
node plugins/comment-rule/bin/comment-rule.mjs file <path>... [--json]
node plugins/comment-rule/bin/comment-rule.mjs count --repo <repo> [--json]

check compares the merge base of --base (default: origin's default branch) and the head (default: the working tree's tracked files) and exits 0 pass, 1 on a prohibited form, 2 could not check. --json gives, per file, comment lines at base and head, the net, each new comment line, and each prohibited form with its line. The write-time hook reports only prohibited forms. count is the drift check: run it on a repo's default branch now and then and compare its total with the last run; steady growth means reviewers are keeping comments they should cut.

• Languages, each with a real parser: TypeScript/JavaScript (the TypeScript compiler API), Python (tokenize comments; docstrings and every other bare string statement count), SQL including dbt (--, nested /* */, dollar quoting, Jinja {# #}), and shell (# comments, not the shebang, not heredoc bodies). Extensionless files count only with a shell or Python shebang; every other file type is ignored. A file its parser cannot read (a Python syntax error, say) makes check exit 2 rather than count it partly.
• Every comment line counts: directives, trailing comments and blank lines inside a block included. Lines split on \r\n, \r, \n, U+2028 and U+2029.
• Repository config .comment-rule.json at the root, read from the tip of --base, never the head, so a change cannot exempt itself and a branch cut before the config landed still gets it (an unresolvable --base exits 2): exclude (globs never counted), frozen (globs that are not counted once they exist at the base, e.g. applied migrations under a checksum, so deleting their comments earns nothing), ticketPrefixes (extra keys such as ABC for ABC-123), sqlDialect (ansi, the default and Postgres's rules; snowflake adds // comments and backslash escapes; bigquery and mysql add # comments and backslash escapes).
• TypeScript 5.x or 6.x is taken from the checked repository, then from the plugin (npm ci --ignore-scripts in plugins/comment-rule), then from a global install. Without one, TypeScript files make check exit 2 rather than pass. CI passes --own-typescript, which skips the checked repository: a pull request controls those files, so it could ship its own node_modules/typescript. Python files need python3; a helper with no result within 60 s (COMMENT_RULE_PYTHON_TIMEOUT_MS) makes check exit 2 rather than hang.

Write-time feedback, never a block. After each edit the post-edit hook checks the edited file against HEAD and, when the file gained a prohibited form, tells the agent which line. Each finding is raised once per session; new comment lines alone are left to review. Claude runs it from Edit|Write|MultiEdit, Codex from apply_patch; OpenCode has no hook manifest, so a host adds plugins/comment-rule/hooks/opencode-comment-rule.mjs to its OpenCode config's plugin list, which appends the same feedback to the edit tool's output. Any error leaves the edit silent.

Lost-constraint review. plugins/comment-rule/review/lost-constraint.md is the prompt for a fresh-context review of a change that deletes or shortens comments ({{BASE}} set to the merge base). No gate runs it, since only a model can judge it. It never answers "keep": each lost constraint comes back with the test, type, assert or lint rule that replaces it and where that goes, or none with the reason code can't check it. The comment stays until that enforcement exists in the change or on the base branch.

Concise

concise is opt-in and applies only to the current conversation. In Claude Code, Codex, or NanoClaw, ask to "use the concise skill". Ask to "turn concise mode off" to restore the session's usual response style. It never becomes a persistent preference, shared instruction, or always-on mode. Start a fresh host session after installing the plugin so its skill catalog includes it.

The canonical skill for every runtime is ~/plugins/bootstrap/plugins/concise/skills/concise/SKILL.md. From the NanoClaw checkout, run the enabler to mirror its skill to OpenCode; Claude and Codex read the declared plugin directly from the container mount:

pnpm exec tsx scripts/enable-agent-plugin.ts bootstrap

Respawn the target agent after an update. Do not copy this skill into container/skills/ or create a NanoClaw always-on ruleset.

Slack humanizer

slack-humanizer loads whenever an agent writes Slack text that goes out under the user's name. It ships a default voice (short, direct, properly capitalized, no AI tells) and rich_text.py, which turns an approved draft into a chat.postMessage payload with one rich_text block, so bullets and numbered lists render as real Slack lists instead of typed • characters.

The plugin carries no person's or company's details. Those live in a private voice profile, slack-voice.md, kept in the workgroup directory, the project root or user memory; the skill reads it when present and describes how to build one from the user's own messages. NanoClaw agents get the skill through the same enabler as concise.

Upgrading from pre-4.0 / pre-1.0

Older Bootstrap releases leaked permanent Codex agent definitions into active runtime homes: six advisor roles before 4.0.0/1.0.0, and worker-frontier up to workflow 5.6.0, installed by a SessionStart hook this release removes. No version ships a permanent agent now. Preview the marker-safe cleanup:

node scripts/retire-bootstrap-agents.mjs

Then apply it:

node scripts/retire-bootstrap-agents.mjs --apply

Dry-run is the default. Apply mode removes only the seven retired basenames carrying the exact Bootstrap ownership marker. Before deletion it writes a timestamped quarantine preserving each file's full home-relative path and a manifest containing its absolute source and SHA-256 hash. Unmanaged collisions, unrelated agents, and plugin caches are preserved. Restart affected Claude, Codex/NanoClaw, or OpenCode sessions after cleanup so cached definitions are unloaded.

Runtime and safety boundaries

• Claude's workflow plugin installs from plugins/workflow.
• Codex/OpenCode's workflow plugin installs from plugins/workflow-agents.
• /orchestrate installs from plugins/orchestrate on every runtime — one directory with both manifests, the wwbd shape. It is invoke-only, with no standing directive, no hooks and no scripts, so it can be disabled without touching the team-* skills or any safety guard.
• skills/shared/ is carried by BOTH workflow plugins, not shared by reference: an installed marketplace cache materializes only the plugin's own subtree, so a relative path cannot cross a plugin boundary. sync-agent-skills.mjs generates the Codex copy from plugins/workflow/skills/shared, and parity-lint fails on any divergence. The orchestrate plugin reads no shared contract, so it carries none.
• Claude and Codex can also install the shared plugins/wwbd advisory plugin.
• Reviewer identities are bounded prompt roles, never globally installed permanent agents.
• Mechanically portable skills and shared contracts are generated from the Claude source tree.
• Shared destructive and protected-file guards are authored once and vendored to the agent plugin.
• Both plugins retain destructive-command, outbound-email, self-approval, managed-clone, Snowflake-connector, and protected-file safety checks.
• bootstrap-workflow-agents declares exactly one hook event, PreToolUse, for those safety checks. check-plugin-boundaries enforces that closed list — the SessionStart entry that used to install a worker role into the user's Codex home went with the role. wwbd declares SessionStart only, for its standing directive; bootstrap-orchestrate uses only its bounded spawn routing, context validation, and Codex picker-reminder hooks.
• Planning and review artifacts are workflow contracts, not filesystem safety boundaries.

Repository structure

bootstrap/
├── .agents/plugins/marketplace.json
├── .claude-plugin/marketplace.json
├── plugins/
│   ├── workflow/
│   ├── workflow-agents/
│   ├── orchestrate/
│   ├── wwbd/
│   ├── comment-rule/
│   ├── concise/
│   └── slack-humanizer/
├── evals/
├── scripts/
└── deprecated/

Development checks

node --test scripts/retire-bootstrap-agents.test.mjs
node --test scripts/plugin-enablement.test.mjs
node --test evals/harness/*.test.mjs
node scripts/check-plugin-boundaries.mjs
node scripts/check-parity.mjs
node --test plugins/comment-rule/test/comment-rule.test.mjs
python3 -m unittest discover -s plugins/slack-humanizer/skills/slack-humanizer -p 'test_*.py'

cd plugins/workflow/hooks && bun test && bun run check
cd plugins/workflow-agents/hooks && bun test && bun run check

Use node scripts/check-plugin-boundaries.mjs --strict-home after retirement cleanup to fail on marker-owned retired agents still active in Claude, Codex sibling-home, or OpenCode agent roots.

Prerequisites

• Claude Code for bootstrap-workflow and bootstrap-orchestrate
• Codex with native plugin support for bootstrap-workflow-agents and bootstrap-orchestrate
• Bun for TypeScript hooks
• Node 22+ and python3 for comment-rule

License

MIT