---
title: "software/constitution™ — adoption: install in hours, governed forever"
description: "How to adopt the software/constitution™ standard in any codebase. The five portable building blocks (kit, wake-up contract, canonical-triple discipline, self-description gate, IP/OSS line) and the install commands."
url: https://kyeprotocol.com/oss/software-constitution/site/adoption/
lang: en
source: "KYE Protocol"
---

> How to adopt the software/constitution™ standard in any codebase. The five portable building blocks (kit, wake-up contract, canonical-triple discipline, self-description gate, IP/OSS line) and the install commands.

• Adoption · v1.1 · Apache 2.0

# Install in hours. / Governed forever.

The standard ships five portable building blocks. Scaffold them into any codebase with one command. Pick the levels you want. Wire the gates into your CI. The constitution is now the layer your agents cannot route around.

This page is the how-to. The standard itself lives at [github.com/Software-Constitution/spec](https://github.com/Software-Constitution/spec); the kit lives at `public/oss/software-constitution/kit/` in any adopting project.

Install

## One command. Zero configuration.

From any project root, run the scaffolder against the path to the target repo. It copies the kit + the wake-up contract + a starter `constitution-kit.json` manifest into the target.

```
# From a repo that already vends the kit (e.g. KYE-Protocol/app):
node public/oss/software-constitution/kit/init.mjs /path/to/your/target-repo

# Then in your target repo:
node public/oss/software-constitution/kit/run.mjs
# → reads constitution-kit.json, runs every declared gate, reports L0–L4 verdict.
```

The kit is single-file at heart (`run.mjs` + `init.mjs`) + a `lib/` + a `recipes/` directory + the manifest schema. No npm install. No build step. Apache 2.0.

The five portable building blocks

## Pick the ones that fit. Add the rest when the codebase outgrows them.

Each is independent. Each is Apache 2.0. Each is the same impl the upstream protocol (KYE Protocol™) dogfoods on its own codebase.

1 / Kit

### Constitution Kit™ — the gate runner

1 / Kit `public/oss/software-constitution/kit/{run.mjs,init.mjs,lib/,schema/,recipes/}`. Reads `constitution-kit.json`, runs every declared gate, emits an L0–L4 verdict. Pluggable recipes (canonical-triple coverage, visual-verify, heartbeat-notification-noise).

2 / Wake-up contract

### Signal-ingest harness (§48)

2 / Wake-up contract `public/oss/software-constitution/kit/wake-up-contract/`. Three independent layers: L1 per-PR webhook, L2 post-push verifier (`verify-ci-triggered.mjs` ≤ 90s), L3 session-resume (`signal-ingest.sh` + `signal-sources.json`). Plus the subagent dead-man's-switch (`subagent-heartbeat-check.mjs`). Silence stops being a state your codebase tolerates.

3 / Canonical-triple discipline

### One implementation per concept

3 / Canonical-triple discipline The §0 red line: _every canonical concept appears exactly once_. The kit ships a recipe (`recipes/canonical-triple-coverage.mjs`) that hard-fails any PR that introduces a parallel implementation of an already-canonical concept.

4 / Self-description gate

### The codebase declares what governs it

4 / Self-description gate Every constitution chapter / amendment binds to at least one executing enforcer. An unenforced chapter carries a decay deadline; silent extension is itself a violation. Pattern: `enforcement-map.json` + a `self-description` gate that fails when the map disagrees with the runtime.

5 / IP/OSS line

### Patent-safe by construction

5 / IP/OSS line Explicit path-rule (§33): what is OSS-track (carries SPDX-License-Identifier: Apache-2.0), what is IP-track (no SPDX, no mechanism content in public/). The kit ships a gate (`ip-oss-line.mjs`) that enforces this on every merge.

Adopting in five steps

## From clone to first green run.

01

### Scaffold the kit

01 Run the one-line install above. The kit lands at `public/oss/software-constitution/kit/`. A starter `constitution-kit.json` lands at your repo root.

02

### Declare your registries

02 Edit `constitution-kit.json` — list the registries your codebase has (schemas, vocabularies, manifests, etc.) + the canonical-uniqueness concepts to enforce.

03

### Wire the wake-up contract

03 Copy `signal-sources.json.template` → `.claude/signal-sources.json` (or your agent harness's equivalent). Add `scripts/ci/verify-ci-triggered.mjs` as a post-push hook.

04

### Add to CI

04 One line in your CI: `node public/oss/software-constitution/kit/run.mjs`. It exits non-zero on any violation. Block merges on it.

05

### Open the first amendment PR

05 The standard now governs the codebase. Every change to a governed surface follows the amendment-PR pattern: declare the lock, name the enforcer, watch the gate go green.

The reference adoption

## KYE Protocol™ dogfoods this standard on itself.

The upstream protocol that produced this kit (KYE Protocol™) runs the exact same files on its own monorepo. 119 gates, 86 self-description subjects bound to enforcers, < 1% unenforced backlog, 53-chapter constitution with every chapter machine-readable. The kit you install is the kit they ship.

If you want to see the maximalist case — a banking-grade regulated-buyer-targeted protocol governed by this standard end-to-end — the source is at [github.com/KYE-Protocol/app](https://github.com/KYE-Protocol/app) (when published). The kit itself is independent and self-contained.

Canonical KYE™ surfaces referenced on this page: [KYE™ Constitution Kit](https://kyeprotocol.com/software-constitution/) · [KYE Protocol™](https://kyeprotocol.com/).
