signum

         _
   _____(_)___ _____  __  ______ ___
  / ___/ / __ `/ __ \/ / / / __ `__ \
 (__  ) / /_/ / / / / /_/ / / / / / /
/____/_/\__, /_/ /_/\__,_/_/ /_/ /_/
       /____/

Write contracts before writing code.

Your AI agent writes code. Signum makes sure it writes the right code.

Landing page · Book a setup call · Discussions

What it does

AI can generate a function in seconds; telling you whether it is correct takes longer, because "correct" isn't defined until someone writes it down. Signum is a contract-first development pipeline for Claude Code that defines correctness before a line is written, then verifies against it deterministically — not by asking another model if the code looks right, but by running acceptance criteria the implementing agent never fully saw. Unlike generic code review, Signum produces a tamper-evident proofpack.json artifact that CI can gate on.

Install

claude plugin marketplace add heurema/emporium
claude plugin install signum@emporium

git clone https://github.com/heurema/signum.git
cd signum
claude plugin install .

Quick start

# Run — describe what you want to build
/signum "your task description"

Signum grades your spec, shows the contract for approval, implements with an automatic repair loop, audits from multiple angles, and produces proofpack.json.

Commands

Features

Spec quality gate — Before implementation starts, your spec is scored across seven dimensions: Testability, Negative coverage, Clarity, Scope boundedness, Completeness, Boundary cases, NL Consistency. Grade D (below 60) is a hard stop with specific feedback on what's missing. The gate runs on the specification, not the code.

Holdout scenarios — The Contractor generates hidden acceptance criteria the Engineer never sees. When implementation is complete, holdouts run against the result — blind testing for cases the agent couldn't optimize for. Verification uses a typed DSL with http, exec (whitelisted binaries only), and expect primitives — no shell execution, no eval. Minimum counts enforced by risk level: 0 for low, 2 for medium, 5 for high.

Project intent alignment — If the target project has a project.intent.md at its root, the contractor reads it before generating contracts. Non-goals and glossary terms flow into contract scope and terminology. For medium/high-risk tasks, missing project intent triggers a blocking question. An LLM-based alignment check warns when the contract diverges from project goals.

Glossary enforcement — A project.glossary.json at the project root defines canonical terms and forbidden synonyms. glossary_check scans contracts for alias usage, terminology_consistency_check detects synonym proliferation across active contracts. Both are WARN-only.

Cross-contract coherence — overlap_check detects inScope file overlap between active contracts. assumption_check flags contradictions in assumptions across related contracts. adr_check warns when relevant ADRs exist but aren't referenced. Contract lineage is tracked via parentContractId, relatedContractIds, and interfacesTouched.

Upstream staleness detection — Contractor computes SHA-256 over upstream artifacts (project.intent.md, project.glossary.json) at contract creation. staleness_check recomputes the hash at execution time. Configurable policy: warn (default) or block.

Within-task refinement — For medium/high-risk tasks, the contractor runs a 4-pass self-critique (ambiguity, missing-input, contradiction, coverage), capped at 2 auto-revision rounds. Typed findings and a readinessForPlanning gate are written to the contract.

Data-level blinding — The Engineer reads contract-engineer.json, not contract.json. Holdout scenarios are physically removed from the file — not hidden by instruction. The agent cannot infer them from context or structure.