by m0n0x41d
Engineering decisions engine that know when they're stale. Frame, compare, decide — with evidence decay and parity enforcement. For Claude Code, Cursor, Gemini CLI, Codex and more.
# Add to your Claude Code skills
git clone https://github.com/m0n0x41d/haftLast scanned: 4/29/2026
{
"issues": [],
"status": "PASSED",
"scannedAt": "2026-04-29T06:23:48.487Z",
"semgrepRan": false,
"npmAuditRan": true,
"pipAuditRan": true
}No comments yet. Be the first to share your thoughts!
formerly quint-code
True harness engineering for AI-assisted software delivery.
Your agents write code fast. Most repositories are not ready for serious harness engineering: the target system is underspecified, the enabling system is implicit, term maps are missing, and runtime evidence is detached from the spec. Haft makes the project harnessable before it scales execution.
Haft is the engineering governor that sits between your intentions and your agents' execution. It enforces the discipline that separates "we shipped fast" from "we shipped right": frame the problem before solving it, compare options under parity, record decisions as falsifiable contracts, and know the moment assumptions go stale.
Specify → Think → Run → Govern.
Not a coding agent. Not a generic documentation tool. The handle between the tool and the hand — the part that turns raw capability into formal specification, governed decisions, bounded commissions, and evidence-backed engineering work.
Both surfaces compile into the same Haft Core artifact graph. MCP does not own long-running runtime lifecycle, and CLI does not become a second source of meaning.
Note: The TUI (
haft agent) and Desktop app exist as alpha tracks under active development. They are not part of the v7 production envelope and are not recommended for production use. The MCP plugin mode (haft serve) andhaft harnessCLI are the stable, proven interfaces.
curl -fsSL https://raw.githubusercontent.com/m0n0x41d/haft/main/install.sh | bash
The install URL still points at the historical quint-code repository path. The installed binary is haft.
Then in your project, run init with your supported host-agent flag:
# Claude Code (default if no flag)
haft init
# Claude Code with repo-local commands
haft init --local
# Codex CLI / Codex App
haft init --codex
# Claude Code + Codex
haft init --all
v7 supported embedded host-agent surfaces:
Claude Code
Codex CLI / Codex App
Cursor, Gemini CLI, JetBrains Air, and generic MCP clients remain experimental/legacy integration targets. Their flags may exist while the runtime and docs converge, but v7 product support is intentionally narrowed to Claude Code and Codex.
# Experimental Cursor config
haft init --cursor
# Experimental Gemini CLI config
haft init --gemini
# Experimental OpenCode config
haft init --opencode
The binary is the same — only the MCP config and command/prompt installation locations differ. Supported v7 hosts:
| Tool | MCP Config | Commands / Prompts | Skill |
|------|-----------|--------------------|-------|
| Claude Code | .mcp.json (project root) | ~/.claude/commands/ or .claude/commands/ with --local | ~/.claude/skills/h-reason/ or local install with --local |
| Codex CLI / Codex App | .codex/config.toml | ~/.codex/prompts/ or .codex/prompts/ with --local | ~/.agents/skills/h-reason/ |
Experimental/legacy hosts:
| Tool | MCP Config | Commands / Prompts | Skill |
|------|-----------|--------------------|-------|
| Cursor | .cursor/mcp.json | ~/.cursor/commands/ or .cursor/commands/ with --local | ~/.cursor/skills/h-reason/ or local install with --local |
| Gemini CLI | ~/.gemini/settings.json | ~/.gemini/commands/ or local install with --local | — |
| OpenCode | opencode.json (project root) | ~/.config/opencode/commands/ or .opencode/commands/ with --local | ~/.config/opencode/skills/h-reason/ or .opencode/skills/h-reason/ with --local |
| Air | .codex/config.toml | project skills/ | project skills/h-reason/ |
Important for Cursor: After init, open Cursor Settings → MCP → find haft → enable the toggle. Cursor adds MCP servers as disabled by default.
Project-scoped MCP configs are safe to commit for shared repositories: Claude
Code .mcp.json and Codex .codex/config.toml use portable project-root
values instead of your machine's absolute checkout path.
Existing project? Run /h-onboard after init. The target direction is deeper
than codebase summarization: onboarding should build a parseable target-system
spec, enabling-system spec, term map, and spec coverage graph before broad
harness execution.
Check the spec carriers locally with:
haft spec check
haft spec check --json
haft spec check is intentionally deterministic L0/L1/L1.5 only: it parses
fenced yaml spec-section blocks, checks required structural fields, validates
known carrier shapes, and verifies that the term-map carrier contains parseable
term entries. It does not make L2 semantic judgments, perform LLM review, prove
product correctness, or make L3 runtime/evidence claims.
| Tool | What it does |
|------|-------------|
| haft_note | Micro-decisions with validation + auto-expiry |
| haft_problem | Frame problems, define comparison dimensions with roles |
| haft_solution | Explore variants with diversity check, compare with parity |
| haft_decision | Decision contract with invariants, claims, evidence, baseline lifecycle |
| haft_commission | WorkCommission create/list/claim lifecycle for execution harnesses |
| haft_refresh | Lifecycle management for all artifacts |
| haft_query | Search, status dashboard, file-to-decision lookup, FPF spec search |
/h-reasonDescribe your problem. The agent frames it, generates alternatives, compares them fairly, and records the decision — all in one command. It auto-selects the right depth.
/h-frame → /h-char → /h-explore → /h-compare → /h-decide
what's what genuinely fair engineering
broken? matters? different comparison contract
options
haft runOnce you have a decision, implement it:
haft run dec-20260414-001
Haft reads the decision's invariants, claims, affected files, and governing invariants from the knowledge graph — then spawns an agent (Codex or Claude) with full reasoning context. After execution, takes a baseline snapshot automatically.
/h-reason "redesign the caching layer"
↓ frame → explore → compare → decide
↓
haft run dec-20260414-001 --agent codex
↓ reads decision → builds prompt → spawns agent
↓ agent implements with invariants as guardrails
↓ baseline snapshot on completion
↓
haft check
↓ verify governance health
Open-Sleigh uses WorkCommission as the bounded execution authority between a
DecisionRecord and a runtime run. In plugin mode, use /h-commission to create
the missing WorkCommissions without starting execution. In Codex this installs
as an explicit-only $h-commission skill.
The packaged CLI path is:
haft harness run --prepare-only # create/reuse commissions, do not start runtime
haft harness run # create/reuse commissions and start Open-Sleigh
haft harness status # inspect active/recent runs
haft harness result wc-... # inspect one completed run and workspace diff
haft harness apply wc-... # apply a completed workspace patch to this checkout
Broad harness execution is blocked for needs_onboard projects by default. If
you intentionally need tactical out-of-spec work, pass
--force-skip-specs "..."; Haft records that reason on the selected
WorkCommissions.
Starting Open-Sleigh is an operator/runtime action. Use the CLI Harness for that boundary rather than a plugin slash command. MCP may create or inspect WorkCommissions, but it must not own the long-running runtime lifecycle.
Commissions carry a delivery_policy. The default is
workspace_patch_manual: Open-Sleigh changes stay in the isolated workspace
until an operator runs haft harness apply <commission-id>. Use
--delivery-policy workspace_patch_manual explicitly when preparing or running
plans that must not mutate the main checkout automatically.
Release installs include the Open-Sleigh runtime under:
~/.haft/runtimes/open-sleigh/current
haft harness run uses a repo-local open-sleigh/ checkout when present and
falls back to that installed runtime. Release archives bundle the BEAM runtime,
so users do not need to install Elixir/Mix for normal harness use. Source
fallback installs may install Elixir when they need to build the runtime
locally.
The lower-level MCP tool is haft_commission; the local CLI helper is:
haft commission create-from-decision dec-...
haft commission create-batch dec-a dec-b
haft commission create-from-plan .haft/plans/implementation.yaml
haft commission create --json commission.json
haft commission list --selector stale
haft commission show wc-...
haft commission requeue wc-... --reason stale_operator_recovery
haft commission cancel wc-... --reason no_longer_relevant
haft commission complete-external wc-... --runner external-runner --reason external_runtime_succeeded --payload-file runtime-evidence.json
haft commission list-runnable
haft commission claim wc-...
For the repeatable local E2E smoke:
task open-sleigh:smoke-real-haft
The same loop is what alpha Desktop workflow buttons compile to. A button must become a typed artifact transition, not a free prompt:
SpecSection(s) -> DecisionRecord -> WorkCommission -> RuntimeRun -> Evidence -> SpecCoverage
Attach evidence to decisions with haft_decision(action="evidence", ...). Evidence has formality levels (F0-F3), congruence level