haft

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.

What is Haft?

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.

Two production surfaces, one core

• MCP plugin — embedded agent surface for Claude Code and Codex to reason, draft, query, and create commissions
• CLI Harness — operator/runtime surface for prepare, run, status, result, apply, requeue, and cancel

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) and haft harness CLI are the stable, proven interfaces.

Install

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

What init does per tool

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.

How It Works

Seven MCP tools

| 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 |

One command: /h-reason

Describe 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.

Or drive each step manually

/h-frame  → /h-char  → /h-explore → /h-compare → /h-decide
  what's      what       genuinely     fair         engineering
  broken?     matters?   different     comparison   contract
                         options

From decision to code: haft run

Once 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

WorkCommission harness

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

Evidence workflow

Attach evidence to decisions with haft_decision(action="evidence", ...). Evidence has formality levels (F0-F3), congruence level