Merge pull request #59 from m0n0x41d/haft/6.1.0

Haft/6.1.0

Author: m0n0x41d

.github/workflows/ci.yml

@@ -87,6 +87,12 @@ jobs:
             exit 1
           fi
 
+      - name: Sync tracked governance artifacts
+        run: ./haft sync
+
+      - name: Check governance debt
+        run: ./haft check
+
       - name: Upload coverage
         uses: codecov/codecov-action@v5
         with:

CHANGELOG.md

@@ -4,7 +4,34 @@ All notable changes to this project will be documented in this file.
 
 The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.1.0/).
 
-## [Unreleased]
+## [6.1.0] — 2026-04-14
+
+### Added
+
+- **`haft check` CLI command** — CI-friendly governance verification. Runs stale scan, drift scan, unassessed decisions, coverage gaps. Exit 0 = clean, exit 1 = findings. `--json` flag for structured output.
+- **Full governance state in `/h-verify`** — scan now surfaces pending problems (backlog/in-progress count), addressed problems without linked decisions, and invariant violations from knowledge graph. Single entry point for "what needs attention."
+- **`.haft/workflow.md` support** — hybrid markdown+YAML project policy file. Parsed at serve/agent startup. Intent + Defaults injected into agent prompts. `haft init` creates commented example.
+- **Problem typing on ProblemCard** — `problem_type` field: optimization, diagnosis, search, synthesis. Accepted on frame, stored in DB, shown in `/h-status` and `/h-problems`.
+- **Derived decision health model** — replaces single "phase" with two independent axes: Maturity (Unassessed / Pending / Shipped) and Freshness (Healthy / Stale / AT RISK). Freshness evaluated only for Shipped decisions. Never stored — computed at query time.
+- **Claim-scoped evidence supersession** — new measurement supersedes only previous measurements for the same `(claim_ref, observable)`, not all measurements on the decision. Prevents unrelated evidence from being retired.
+- **Claim-scoped R_eff** — `R_eff(decision) = min(R_eff(claim_i))` where each claim's R_eff is computed from its own evidence. More precise than decision-level aggregation.
+- **F_eff / G_eff decomposition** — Formality (F0–F3) and Groundedness (CL-derived) exposed as view concerns alongside R_eff for evidence diagnosis.
+- **Deep onboard for legacy projects** — `/h-onboard` now runs module coverage analysis and deep scans blind modules: reads code, identifies responsibilities, invariants, implicit decisions, risks. Supports parallel subagent execution when available.
+
+### Changed
+
+- **"No evidence = Unassessed"** — decisions without evidence are shown separately from healthy decisions, not treated as fresh. UI surfaces coverage gaps.
+- **Verdict vocabulary normalized** — measurement result aliases (`accepted`/`partial`/`failed`) mapped to canonical evidence verdicts (`supports`/`weakens`/`refutes`) at storage boundary.
+- **CL0 + supports = inadmissible** — evidence from opposed context with verdict `supports` is rejected at ingest, not merely penalized.
+- **G1 enforced: one active decision per problem** — `Decide()` rejects if another active DecisionRecord exists for the same problem_ref.
+- **G2: parity plan warnings** — `haft_solution(action="compare")` in standard/deep mode warns if parity plan is empty or unstructured.
+- **G4: subjective dimension warnings** — compare warns on dimensions like "maintainable", "simple", "scalable" — asks to decompose into measurables or tag as observation-only.
+- **Core boundary enforced** — integration tests verify Core packages (`internal/artifact`, `graph`, `fpf`, `reff`, `codebase`) have zero `desktop/` imports.
+
+### Fixed
+
+- **Desktop: oversized task output tails bounded** — prevents UI freeze on large agent outputs.
+- **Knowledge graph integration tests** — FindDecisionsForFile, FindInvariantsForFile, ComputeImpactSet tested on seeded DB with real project data.
 
 ## [6.0.0] — 2026-04-13
 

README.md

@@ -2,18 +2,20 @@
 
 *formerly [quint-code](https://github.com/m0n0x41d/quint-code)*
 
-**Engineering decisions that know when they're stale.**
+**True harness engineering for AI-assisted software delivery.**
 
-Frame problems. Compare options fairly. Record decisions as contracts. Know when to revisit.
+Your agents write code fast. Nobody checks if the decisions behind that code are any good — or still valid a month later. Haft does.
 
 ---
 
 ## What is Haft?
 
-Haft is a local-first engineering governor for software projects. It helps engineers frame problems before solving them, compare options honestly, record decisions as contracts with invariants, track evidence with decay, and know when to revisit.
+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.
 
 **Think → Run → Govern.**
 
+Not a coding agent. Not a documentation tool. Not a project manager. The handle between the tool and the hand — the part that turns raw capability into directed engineering work.
+
 ### Two primary surfaces
 
 - **Desktop app** — visual cockpit for reasoning state, agent orchestration, and governance dashboard
@@ -74,6 +76,30 @@ The binary is the same — only the MCP config and command/prompt installation l
 
 Existing project? Run `/h-onboard` after init — the agent scans your codebase for existing decisions worth capturing.
 
+## CI
+
+Use `haft check` anywhere you want a pass/fail signal for governance debt:
+
+```yaml
+# .github/workflows/haft-check.yml
+steps:
+  - uses: actions/checkout@v4
+
+  - name: Install haft
+    run: |
+      curl -fsSL https://raw.githubusercontent.com/m0n0x41d/haft/main/install.sh | bash
+      echo "$HOME/.local/bin" >> "$GITHUB_PATH"
+
+  - name: Check governance debt
+    run: haft check
+```
+
+`haft check` scans stale artifacts, drifted decisions, unassessed decisions, and coverage gaps.
+Exit `0` means the project is clean. Governance findings exit `1`. Command or setup errors also
+fail the job with a non-zero exit code, which keeps CI badges red for both unhealthy and broken states.
+
+Need machine-readable output? Run `haft check --json`.
+
 ---
 
 ## How It Works
@@ -147,6 +173,43 @@ Features: dashboard with governance findings, problem board, decision detail wit
 
 ---
 
+## Roadmap
+
+### v6.1 — Harden the Contract (shipped)
+
+Decision quality enforcement before automating execution:
+- `haft check` for CI governance verification
+- `/h-verify` surfaces full governance state (problems, invariants, drift — not just decisions)
+- `.haft/workflow.md` — repo-level agent policy, injected into every prompt
+- Problem typing (optimization / diagnosis / search / synthesis)
+- G1/G2/G4 enforcement: one decision per problem, parity warnings, subjective dimension detection
+- CL0+supports rejection, claim-scoped R_eff and evidence supersession
+- Deep `/h-onboard` with module-by-module analysis for legacy projects
+
+### v6.2 — Dashboard + Execution Primitives (next)
+
+The desktop becomes an operator surface, not just a viewer:
+- **Unified Dashboard** — active decisions, governance findings, automations in one view
+- **Implement** — click a decision, agent spawns in worktree with full reasoning context
+- **Adopt** — governance finding (stale/drifted) → agent thread for interactive resolution
+- **Automation triggers** — CI fail, dependency update, scheduled → auto-create ProblemCards
+- **DDR→Task Pipeline** — Implement generates subtasks from decision, runs sequentially with auto-advance
+- **Deep onboard** — `/h-onboard --deep` generates task plan from coverage gaps
+
+### v7 — Desktop Loop MVP
+
+One proved cycle: **Decision → Implement → Verify → Baseline → PR draft**. If verification fails → reopen as ProblemCard, not straight to PR. Local-first PR output.
+
+### v8 — Governor Signals
+
+Background detection loops (stale, drift, dependencies) with dashboard alerts. Autonomous actuation only after trust is earned through detect-only phase.
+
+### Not on the roadmap
+
+Cloud/SaaS. Mobile app. Slack bot. Browser extension. General personal assistant. Competing with Claude Code on code editing. The product is the engineering governor, not another surface.
+
+---
+
 ## Requirements
 
 - Go 1.25+ (for building from source)

desktop/agents.go

@@ -26,6 +26,7 @@ const (
 
 const (
 	taskOutputMaxLines      = 500
+	taskOutputMaxChars      = 64000
 	taskOutputFlushInterval = 350 * time.Millisecond
 )
 
@@ -53,8 +54,8 @@ type TaskState struct {
 	StartedAt      string `json:"started_at"`
 	CompletedAt    string `json:"completed_at"`
 	ErrorMessage   string `json:"error_message"`
-	Output         string `json:"output"` // bounded output tail
-	AutoRun        bool   `json:"auto_run"`       // true = agent runs without pausing
+	Output         string `json:"output"`   // bounded output tail
+	AutoRun        bool   `json:"auto_run"` // true = agent runs without pausing
 }
 
 type TaskOutputEvent struct {
@@ -464,14 +465,30 @@ func (b *taskOutputBuffer) Append(chunk string) string {
 		b.lines = append([]string(nil), b.lines[len(b.lines)-b.maxLines:]...)
 	}
 
-	return b.snapshotLocked()
+	snapshot := b.snapshotLocked()
+	normalized := normalizeTaskOutput(snapshot)
+
+	if normalized != snapshot {
+		b.lines = nil
+		b.partial = normalized
+	}
+
+	return normalized
 }
 
 func (b *taskOutputBuffer) String() string {
 	b.mu.Lock()
 	defer b.mu.Unlock()
 
-	return b.snapshotLocked()
+	snapshot := b.snapshotLocked()
+	normalized := normalizeTaskOutput(snapshot)
+
+	if normalized != snapshot {
+		b.lines = nil
+		b.partial = normalized
+	}
+
+	return normalized
 }
 
 func (b *taskOutputBuffer) snapshotLocked() string {
@@ -487,6 +504,43 @@ func (b *taskOutputBuffer) snapshotLocked() string {
 	return strings.Join(parts, "\n")
 }
 
+func normalizeTaskOutput(output string) string {
+	bounded := trimTaskOutputLines(output, taskOutputMaxLines)
+	bounded = trimTaskOutputRunes(bounded, taskOutputMaxChars)
+	return bounded
+}
+
+func trimTaskOutputLines(output string, maxLines int) string {
+	if output == "" || maxLines <= 0 {
+		return output
+	}
+
+	lines := strings.Split(output, "\n")
+
+	if len(lines) <= maxLines {
+		return output
+	}
+
+	start := len(lines) - maxLines
+	tail := lines[start:]
+	return strings.Join(tail, "\n")
+}
+
+func trimTaskOutputRunes(output string, maxRunes int) string {
+	if output == "" || maxRunes <= 0 {
+		return output
+	}
+
+	runes := []rune(output)
+
+	if len(runes) <= maxRunes {
+		return output
+	}
+
+	start := len(runes) - maxRunes
+	return string(runes[start:])
+}
+
 // --- App binding methods ---
 
 // DetectAgents finds installed coding agents.

desktop/agents_test.go

@@ -0,0 +1,62 @@
+package main
+
+import (
+	"fmt"
+	"strings"
+	"testing"
+	"unicode/utf8"
+)
+
+func TestTaskOutputBufferKeepsNewestLongSingleLine(t *testing.T) {
+	buffer := newTaskOutputBuffer(taskOutputMaxLines, "")
+	head := "STARTMARKER"
+	tail := strings.Repeat("tail", 2000) + "ENDMARKER"
+	body := strings.Repeat("H", taskOutputMaxChars)
+	longLine := head + body + tail
+
+	got := buffer.Append(longLine)
+
+	if utf8.RuneCountInString(got) > taskOutputMaxChars {
+		t.Fatalf("expected output <= %d runes, got %d", taskOutputMaxChars, utf8.RuneCountInString(got))
+	}
+
+	if strings.Contains(got, "STARTMARKER") {
+		t.Fatalf("expected oldest prefix marker to be trimmed from output")
+	}
+
+	if !strings.HasSuffix(got, "ENDMARKER") {
+		t.Fatalf("expected newest output tail to be preserved, got suffix %q", got[maxInt(len(got)-32, 0):])
+	}
+}
+
+func TestNormalizeTaskOutputKeepsNewestLines(t *testing.T) {
+	lines := make([]string, 0, taskOutputMaxLines+25)
+
+	for i := range taskOutputMaxLines + 25 {
+		lines = append(lines, fmt.Sprintf("line-%03d", i))
+	}
+
+	output := strings.Join(lines, "\n")
+	got := normalizeTaskOutput(output)
+	gotLines := strings.Split(got, "\n")
+
+	if len(gotLines) != taskOutputMaxLines {
+		t.Fatalf("expected %d lines after normalization, got %d", taskOutputMaxLines, len(gotLines))
+	}
+
+	if gotLines[0] != "line-025" {
+		t.Fatalf("expected first retained line line-025, got %q", gotLines[0])
+	}
+
+	if gotLines[len(gotLines)-1] != "line-524" {
+		t.Fatalf("expected last retained line line-524, got %q", gotLines[len(gotLines)-1])
+	}
+}
+
+func maxInt(a int, b int) int {
+	if a > b {
+		return a
+	}
+
+	return b
+}

desktop/app.go

@@ -145,17 +145,29 @@ func (a *App) GetDashboard() (*DashboardView, error) {
 	stale, _ := a.store.FindStaleArtifacts(a.ctx)
 	notes, _ := a.store.ListActiveByKind(a.ctx, artifact.KindNote, 50)
 	portfolios, _ := a.store.ListActiveByKind(a.ctx, artifact.KindSolutionPortfolio, 100)
+	statusData, err := artifact.FetchStatusData(a.ctx, a.store, "")
+	if err != nil {
+		return nil, err
+	}
+
+	healthyDecisions := mapArtifacts(statusData.HealthyDecisions, toDecisionView, 8)
+	pendingDecisions := mapArtifacts(statusData.PendingDecisions, toDecisionView, 8)
+	unassessedDecisions := mapArtifacts(statusData.UnassessedDecisions, toDecisionView, 8)
+	recentDecisions := mapArtifacts(decisions, toDecisionView, 8)
 
 	return &DashboardView{
-		ProjectName:     a.projectName,
-		ProblemCount:    len(problems),
-		DecisionCount:   len(decisions),
-		PortfolioCount:  len(portfolios),
-		NoteCount:       len(notes),
-		StaleCount:      len(stale),
-		RecentProblems:  mapArtifacts(problems, toProblemView, 8),
-		RecentDecisions: mapArtifacts(decisions, toDecisionView, 8),
-		StaleItems:      mapArtifacts(stale, toArtifactView, 10),
+		ProjectName:         a.projectName,
+		ProblemCount:        len(problems),
+		DecisionCount:       len(decisions),
+		PortfolioCount:      len(portfolios),
+		NoteCount:           len(notes),
+		StaleCount:          len(stale),
+		RecentProblems:      mapArtifacts(problems, toProblemView, 8),
+		RecentDecisions:     safeDecisionViews(recentDecisions),
+		HealthyDecisions:    safeDecisionViews(healthyDecisions),
+		PendingDecisions:    safeDecisionViews(pendingDecisions),
+		UnassessedDecisions: safeDecisionViews(unassessedDecisions),
+		StaleItems:          mapArtifacts(stale, toArtifactView, 10),
 	}, nil
 }