From 10db5f4b549953b6201243f383994140cba81280 Mon Sep 17 00:00:00 2001
From: Test <test@test.com>
Date: Tue, 28 Jul 2026 15:53:56 -0300
Subject: [PATCH 1/3] research: validate reproducible evidence from agent
 history

Add a content-free Codex evidence scanner and a TDD-built, path-safe ordered patch replayer. Validate repository and turn-level evidence across the local corpus, exercise verification inside a locked-down Docker container, and document the critical finding that legacy sessions omit the initial dirty-worktree baseline required for deterministic replay.
---
 _roadmap.md                      |   3 +
 internal/evidence/codex.go       | 216 ++++++++++++++++++
 internal/evidence/codex_test.go  | 158 +++++++++++++
 internal/evidence/replay.go      | 371 +++++++++++++++++++++++++++++++
 internal/evidence/replay_test.go | 210 +++++++++++++++++
 scripts/evidence-audit/main.go   |  73 ++++++
 6 files changed, 1031 insertions(+)
 create mode 100644 internal/evidence/codex.go
 create mode 100644 internal/evidence/codex_test.go
 create mode 100644 internal/evidence/replay.go
 create mode 100644 internal/evidence/replay_test.go
 create mode 100644 scripts/evidence-audit/main.go

diff --git a/_roadmap.md b/_roadmap.md
index 47c9edc..ae183d9 100644
--- a/_roadmap.md
+++ b/_roadmap.md
@@ -38,4 +38,7 @@ engineering portfolio.
 - [x] Propagate cancellation through agent-run command process trees and report local-model telemetry without false precision.
 - [x] Remove the disconnected legacy `monitor` and imperative `release` command implementations while preserving public-surface compatibility tests.
 - [ ] Isolate Live as an optional local observability protocol and retire unused training and experimental command surfaces.
+- [x] Build a content-free Codex history scanner and validate turn-level Git, patch, verification, and completion evidence against the local corpus.
+- [x] Build and container-validate a path-safe historical patch replayer, and establish that legacy Codex sessions lack the dirty-worktree baseline needed for deterministic replay.
+- [ ] Capture an initial base diff or snapshot in new sessions, prove deterministic replay end to end, then add an OpenCode importer to challenge the vendor-neutral evidence model.
 - [ ] Raise coverage in legacy workflow packages without presenting the public fixture as repository-wide coverage.
diff --git a/internal/evidence/codex.go b/internal/evidence/codex.go
new file mode 100644
index 0000000..eae4034
--- /dev/null
+++ b/internal/evidence/codex.go
@@ -0,0 +1,216 @@
+package evidence
+
+import (
+	"bufio"
+	"encoding/json"
+	"fmt"
+	"io/fs"
+	"os"
+	"path/filepath"
+	"regexp"
+	"strings"
+)
+
+const maxEventBytes = 16 << 20
+
+var verificationCommand = regexp.MustCompile(
+	`(?i)(^|[[:space:];|&])(go test|go vet|make verify|mix test|mix credo|mix format|` +
+		`npm test|npm run lint|pytest|ruff check|cargo test|bundle exec|golangci-lint|` +
+		`staticcheck|eslint|tsc)([[:space:];|&]|$)`,
+)
+
+// CodexSummary contains aggregate evidence counts only. It intentionally
+// excludes prompts, outputs, paths, repository URLs, commit hashes, commands,
+// session identifiers, and other potentially sensitive values.
+type CodexSummary struct {
+	Sessions                int `json:"sessions"`
+	SessionsWithGit         int `json:"sessions_with_git"`
+	Commands                int `json:"commands"`
+	SuccessfulCommands      int `json:"successful_commands"`
+	FailedCommands          int `json:"failed_commands"`
+	VerificationCommands    int `json:"verification_commands"`
+	SuccessfulVerifications int `json:"successful_verifications"`
+	Patches                 int `json:"patches"`
+	CompletedTasks          int `json:"completed_tasks"`
+	Level3CandidateTurns    int `json:"level3_candidate_turns"`
+}
+
+type codexEvent struct {
+	Type    string          `json:"type"`
+	Payload json.RawMessage `json:"payload"`
+}
+
+type sessionEvidence struct {
+	hasMetadata bool
+	hasGit      bool
+	turns       map[string]*turnEvidence
+}
+
+type turnEvidence struct {
+	hasSuccessfulPatch  bool
+	hasSuccessfulVerify bool
+	hasCompletion       bool
+}
+
+// ScanCodex reads Codex JSONL session files and returns content-free aggregate
+// evidence metrics. It never returns or persists raw event values.
+func ScanCodex(root string) (CodexSummary, error) {
+	var summary CodexSummary
+
+	err := filepath.WalkDir(root, func(path string, entry fs.DirEntry, walkErr error) error {
+		if walkErr != nil {
+			return walkErr
+		}
+		if entry.IsDir() || filepath.Ext(path) != ".jsonl" {
+			return nil
+		}
+
+		session, err := scanCodexSession(path, &summary)
+		if err != nil {
+			return err
+		}
+		if session.hasMetadata {
+			summary.Sessions++
+		}
+		if session.hasGit {
+			summary.SessionsWithGit++
+		}
+		if session.hasGit {
+			for _, turn := range session.turns {
+				if turn.hasSuccessfulPatch &&
+					turn.hasSuccessfulVerify &&
+					turn.hasCompletion {
+					summary.Level3CandidateTurns++
+				}
+			}
+		}
+		return nil
+	})
+	if err != nil {
+		return CodexSummary{}, fmt.Errorf("scanning Codex sessions: %w", err)
+	}
+
+	return summary, nil
+}
+
+func scanCodexSession(path string, summary *CodexSummary) (sessionEvidence, error) {
+	file, err := os.Open(path)
+	if err != nil {
+		return sessionEvidence{}, fmt.Errorf("opening session file: %w", err)
+	}
+	defer file.Close()
+
+	session := sessionEvidence{turns: make(map[string]*turnEvidence)}
+	scanner := bufio.NewScanner(file)
+	scanner.Buffer(make([]byte, 64<<10), maxEventBytes)
+
+	for line := 1; scanner.Scan(); line++ {
+		var event codexEvent
+		if err := json.Unmarshal(scanner.Bytes(), &event); err != nil {
+			return sessionEvidence{}, fmt.Errorf("decoding session event at line %d: %w", line, err)
+		}
+		if err := countCodexEvent(event, summary, &session); err != nil {
+			return sessionEvidence{}, fmt.Errorf("reading session event at line %d: %w", line, err)
+		}
+	}
+	if err := scanner.Err(); err != nil {
+		return sessionEvidence{}, fmt.Errorf("reading session file: %w", err)
+	}
+
+	return session, nil
+}
+
+func countCodexEvent(event codexEvent, summary *CodexSummary, session *sessionEvidence) error {
+	var payload map[string]any
+	if len(event.Payload) > 0 {
+		if err := json.Unmarshal(event.Payload, &payload); err != nil {
+			return err
+		}
+	}
+
+	if event.Type == "session_meta" {
+		session.hasMetadata = true
+		_, session.hasGit = payload["git"].(map[string]any)
+		return nil
+	}
+
+	eventType, _ := payload["type"].(string)
+	turn := session.turn(payload)
+	switch eventType {
+	case "exec_command_end":
+		countCommand(payload, summary, turn)
+	case "patch_apply_end":
+		if success, _ := payload["success"].(bool); success {
+			summary.Patches++
+			if turn != nil {
+				turn.hasSuccessfulPatch = true
+			}
+		}
+	case "task_complete":
+		summary.CompletedTasks++
+		if turn != nil {
+			turn.hasCompletion = true
+		}
+	}
+	return nil
+}
+
+func countCommand(payload map[string]any, summary *CodexSummary, turn *turnEvidence) {
+	summary.Commands++
+
+	exitCode, hasExitCode := numberAsInt(payload["exit_code"])
+	if hasExitCode && exitCode == 0 {
+		summary.SuccessfulCommands++
+	} else {
+		summary.FailedCommands++
+	}
+
+	command := commandText(payload["command"])
+	if !verificationCommand.MatchString(command) {
+		return
+	}
+
+	summary.VerificationCommands++
+	if hasExitCode && exitCode == 0 {
+		summary.SuccessfulVerifications++
+		if turn != nil {
+			turn.hasSuccessfulVerify = true
+		}
+	}
+}
+
+func (session *sessionEvidence) turn(payload map[string]any) *turnEvidence {
+	turnID, _ := payload["turn_id"].(string)
+	if turnID == "" {
+		return nil
+	}
+	if session.turns[turnID] == nil {
+		session.turns[turnID] = &turnEvidence{}
+	}
+	return session.turns[turnID]
+}
+
+func commandText(value any) string {
+	switch command := value.(type) {
+	case string:
+		return command
+	case []any:
+		parts := make([]string, 0, len(command))
+		for _, part := range command {
+			if text, ok := part.(string); ok {
+				parts = append(parts, text)
+			}
+		}
+		return strings.Join(parts, " ")
+	default:
+		return ""
+	}
+}
+
+func numberAsInt(value any) (int, bool) {
+	number, ok := value.(float64)
+	if !ok {
+		return 0, false
+	}
+	return int(number), true
+}
diff --git a/internal/evidence/codex_test.go b/internal/evidence/codex_test.go
new file mode 100644
index 0000000..b76cc58
--- /dev/null
+++ b/internal/evidence/codex_test.go
@@ -0,0 +1,158 @@
+package evidence
+
+import (
+	"encoding/json"
+	"os"
+	"path/filepath"
+	"strings"
+	"testing"
+)
+
+func TestScanCodexSummarizesEvidenceWithoutLeakingContent(t *testing.T) {
+	t.Parallel()
+
+	root := t.TempDir()
+	writeSession(t, root, "candidate.jsonl", []map[string]any{
+		event("session_meta", map[string]any{
+			"id":  "session-sensitive-id",
+			"cwd": "/private/customer/repository",
+			"git": map[string]any{
+				"branch":         "private-branch",
+				"commit_hash":    "abc123",
+				"repository_url": "git@example.com:customer/private.git",
+			},
+		}),
+		event("event_msg", map[string]any{
+			"type":      "exec_command_end",
+			"turn_id":   "turn-1",
+			"command":   []string{"/bin/zsh", "-lc", "go test ./..."},
+			"exit_code": 0,
+			"stdout":    "SECRET_OUTPUT",
+		}),
+		event("event_msg", map[string]any{
+			"type":    "patch_apply_end",
+			"turn_id": "turn-1",
+			"success": true,
+			"changes": []any{map[string]any{"path": "secret.go"}},
+		}),
+		event("event_msg", map[string]any{"type": "task_complete", "turn_id": "turn-1"}),
+	})
+	writeSession(t, root, "incomplete.jsonl", []map[string]any{
+		event("session_meta", map[string]any{
+			"id":  "another-sensitive-id",
+			"cwd": "/private/other",
+		}),
+		event("event_msg", map[string]any{
+			"type":      "exec_command_end",
+			"command":   "rm -rf build",
+			"exit_code": 1,
+			"stderr":    "SECRET_ERROR",
+		}),
+	})
+	writeSession(t, root, "uncorrelated.jsonl", []map[string]any{
+		event("session_meta", map[string]any{
+			"id":  "uncorrelated-sensitive-id",
+			"cwd": "/private/uncorrelated",
+			"git": map[string]any{"commit_hash": "def456"},
+		}),
+		event("event_msg", map[string]any{
+			"type":    "patch_apply_end",
+			"turn_id": "turn-a",
+			"success": true,
+		}),
+		event("event_msg", map[string]any{
+			"type":      "exec_command_end",
+			"turn_id":   "turn-b",
+			"command":   "go test ./...",
+			"exit_code": 0,
+		}),
+		event("event_msg", map[string]any{"type": "task_complete", "turn_id": "turn-c"}),
+	})
+
+	summary, err := ScanCodex(root)
+	if err != nil {
+		t.Fatalf("ScanCodex() error = %v", err)
+	}
+
+	if summary.Sessions != 3 {
+		t.Errorf("Sessions = %d, want 3", summary.Sessions)
+	}
+	if summary.SessionsWithGit != 2 {
+		t.Errorf("SessionsWithGit = %d, want 2", summary.SessionsWithGit)
+	}
+	if summary.Commands != 3 || summary.SuccessfulCommands != 2 || summary.FailedCommands != 1 {
+		t.Errorf(
+			"command counts = (%d, %d, %d), want (3, 2, 1)",
+			summary.Commands,
+			summary.SuccessfulCommands,
+			summary.FailedCommands,
+		)
+	}
+	if summary.VerificationCommands != 2 || summary.SuccessfulVerifications != 2 {
+		t.Errorf(
+			"verification counts = (%d, %d), want (2, 2)",
+			summary.VerificationCommands,
+			summary.SuccessfulVerifications,
+		)
+	}
+	if summary.Patches != 2 || summary.CompletedTasks != 2 {
+		t.Errorf("result counts = (%d, %d), want (2, 2)", summary.Patches, summary.CompletedTasks)
+	}
+	if summary.Level3CandidateTurns != 1 {
+		t.Errorf("Level3CandidateTurns = %d, want 1", summary.Level3CandidateTurns)
+	}
+
+	encoded, err := json.Marshal(summary)
+	if err != nil {
+		t.Fatalf("json.Marshal() error = %v", err)
+	}
+	for _, secret := range []string{
+		"customer",
+		"private-branch",
+		"abc123",
+		"SECRET_OUTPUT",
+		"SECRET_ERROR",
+		"session-sensitive-id",
+	} {
+		if strings.Contains(string(encoded), secret) {
+			t.Errorf("summary leaked sensitive value %q", secret)
+		}
+	}
+}
+
+func TestScanCodexRejectsMalformedJSONL(t *testing.T) {
+	t.Parallel()
+
+	root := t.TempDir()
+	if err := os.WriteFile(filepath.Join(root, "broken.jsonl"), []byte("{broken\n"), 0o600); err != nil {
+		t.Fatal(err)
+	}
+
+	if _, err := ScanCodex(root); err == nil {
+		t.Fatal("ScanCodex() error = nil, want malformed JSON error")
+	}
+}
+
+func event(kind string, payload map[string]any) map[string]any {
+	return map[string]any{
+		"type":    kind,
+		"payload": payload,
+	}
+}
+
+func writeSession(t *testing.T, root, name string, events []map[string]any) {
+	t.Helper()
+
+	var lines []byte
+	for _, item := range events {
+		encoded, err := json.Marshal(item)
+		if err != nil {
+			t.Fatal(err)
+		}
+		lines = append(lines, encoded...)
+		lines = append(lines, '\n')
+	}
+	if err := os.WriteFile(filepath.Join(root, name), lines, 0o600); err != nil {
+		t.Fatal(err)
+	}
+}
diff --git a/internal/evidence/replay.go b/internal/evidence/replay.go
new file mode 100644
index 0000000..224faaa
--- /dev/null
+++ b/internal/evidence/replay.go
@@ -0,0 +1,371 @@
+package evidence
+
+import (
+	"bufio"
+	"bytes"
+	"context"
+	"encoding/json"
+	"errors"
+	"fmt"
+	"os"
+	"os/exec"
+	"path/filepath"
+	"strings"
+)
+
+// FileChange is one ordered filesystem mutation reconstructed from a recorded
+// patch event.
+type FileChange struct {
+	Path        string `json:"-"`
+	Type        string `json:"-"`
+	Content     string `json:"-"`
+	UnifiedDiff string `json:"-"`
+	MovePath    string `json:"-"`
+}
+
+// ReplayPlan contains sensitive local reconstruction inputs and is explicitly
+// excluded from JSON serialization.
+type ReplayPlan struct {
+	RepositoryRoot string       `json:"-"`
+	BaseCommit     string       `json:"-"`
+	Changes        []FileChange `json:"-"`
+}
+
+type replayPayload struct {
+	Type    string          `json:"type"`
+	TurnID  string          `json:"turn_id"`
+	Success bool            `json:"success"`
+	CWD     string          `json:"cwd"`
+	Git     replayGit       `json:"git"`
+	Changes json.RawMessage `json:"changes"`
+}
+
+type replayGit struct {
+	CommitHash string `json:"commit_hash"`
+}
+
+type recordedChange struct {
+	Type        string `json:"type"`
+	Content     string `json:"content"`
+	UnifiedDiff string `json:"unified_diff"`
+	MovePath    string `json:"move_path"`
+}
+
+// ExtractReplayPlan reconstructs the ordered filesystem mutations from the
+// session start through completion of targetTurn.
+func ExtractReplayPlan(sessionPath, targetTurn string) (ReplayPlan, error) {
+	if targetTurn == "" {
+		return ReplayPlan{}, errors.New("target turn is required")
+	}
+
+	file, err := os.Open(sessionPath)
+	if err != nil {
+		return ReplayPlan{}, fmt.Errorf("opening session file: %w", err)
+	}
+	defer file.Close()
+
+	var plan ReplayPlan
+	foundTarget := false
+	scanner := bufio.NewScanner(file)
+	scanner.Buffer(make([]byte, 64<<10), maxEventBytes)
+	for line := 1; scanner.Scan(); line++ {
+		var event codexEvent
+		if err := json.Unmarshal(scanner.Bytes(), &event); err != nil {
+			return ReplayPlan{}, fmt.Errorf("decoding session event at line %d: %w", line, err)
+		}
+
+		var payload replayPayload
+		if err := json.Unmarshal(event.Payload, &payload); err != nil {
+			return ReplayPlan{}, fmt.Errorf("decoding replay event at line %d: %w", line, err)
+		}
+		if event.Type == "session_meta" {
+			plan.RepositoryRoot = payload.CWD
+			plan.BaseCommit = payload.Git.CommitHash
+			continue
+		}
+		if payload.Type == "patch_apply_end" && payload.Success {
+			changes, err := decodeRecordedChanges(payload.Changes)
+			if err != nil {
+				return ReplayPlan{}, fmt.Errorf("decoding changes at line %d: %w", line, err)
+			}
+			changes, err = normalizeRecordedChanges(plan.RepositoryRoot, changes)
+			if err != nil {
+				return ReplayPlan{}, fmt.Errorf("normalizing changes at line %d: %w", line, err)
+			}
+			plan.Changes = append(plan.Changes, changes...)
+		}
+		if payload.Type == "task_complete" && payload.TurnID == targetTurn {
+			foundTarget = true
+			break
+		}
+	}
+	if err := scanner.Err(); err != nil {
+		return ReplayPlan{}, fmt.Errorf("reading session file: %w", err)
+	}
+	if !foundTarget {
+		return ReplayPlan{}, errors.New("target turn completion was not found")
+	}
+	if plan.RepositoryRoot == "" || plan.BaseCommit == "" {
+		return ReplayPlan{}, errors.New("session is missing repository root or base commit")
+	}
+
+	return plan, nil
+}
+
+func decodeRecordedChanges(raw json.RawMessage) ([]FileChange, error) {
+	if len(raw) == 0 || string(raw) == "null" {
+		return nil, nil
+	}
+
+	decoder := json.NewDecoder(bytes.NewReader(raw))
+	token, err := decoder.Token()
+	if err != nil {
+		return nil, err
+	}
+	if delimiter, ok := token.(json.Delim); !ok || delimiter != '{' {
+		return nil, errors.New("changes must be a JSON object")
+	}
+
+	var changes []FileChange
+	for decoder.More() {
+		pathToken, err := decoder.Token()
+		if err != nil {
+			return nil, err
+		}
+		path, ok := pathToken.(string)
+		if !ok {
+			return nil, errors.New("change path must be a string")
+		}
+		var recorded recordedChange
+		if err := decoder.Decode(&recorded); err != nil {
+			return nil, err
+		}
+		changes = append(changes, FileChange{
+			Path:        path,
+			Type:        recorded.Type,
+			Content:     recorded.Content,
+			UnifiedDiff: recorded.UnifiedDiff,
+			MovePath:    recorded.MovePath,
+		})
+	}
+	if _, err := decoder.Token(); err != nil {
+		return nil, err
+	}
+	return changes, nil
+}
+
+func normalizeRecordedChanges(root string, changes []FileChange) ([]FileChange, error) {
+	if root == "" {
+		return nil, errors.New("repository root must precede patch events")
+	}
+	absoluteRoot, err := filepath.Abs(root)
+	if err != nil {
+		return nil, fmt.Errorf("resolving repository root: %w", err)
+	}
+
+	normalized := make([]FileChange, 0, len(changes))
+	for _, change := range changes {
+		change.Path, err = recordedRelativePath(absoluteRoot, change.Path)
+		if err != nil {
+			return nil, err
+		}
+		if change.MovePath != "" {
+			change.MovePath, err = recordedRelativePath(absoluteRoot, change.MovePath)
+			if err != nil {
+				return nil, fmt.Errorf("normalizing move destination: %w", err)
+			}
+		}
+		normalized = append(normalized, change)
+	}
+	return normalized, nil
+}
+
+func recordedRelativePath(root, recorded string) (string, error) {
+	if recorded == "" {
+		return "", errors.New("recorded path is empty")
+	}
+	if !filepath.IsAbs(recorded) {
+		return filepath.Clean(recorded), nil
+	}
+
+	relative, err := filepath.Rel(root, filepath.Clean(recorded))
+	if err != nil {
+		return "", fmt.Errorf("relativizing recorded path: %w", err)
+	}
+	if relative == ".." || strings.HasPrefix(relative, ".."+string(filepath.Separator)) {
+		return "", errors.New("recorded path is outside repository root")
+	}
+	return relative, nil
+}
+
+// ApplyChanges applies a previously validated, ordered patch sequence inside
+// root. The operation rejects paths that can escape root or alter Git metadata.
+func ApplyChanges(ctx context.Context, root string, changes []FileChange) error {
+	absoluteRoot, err := filepath.Abs(root)
+	if err != nil {
+		return fmt.Errorf("resolving replay root: %w", err)
+	}
+
+	for index, change := range changes {
+		if err := validateChange(absoluteRoot, change); err != nil {
+			return fmt.Errorf("validating change %d: %w", index+1, err)
+		}
+	}
+
+	for index, change := range changes {
+		if err := applyChange(ctx, absoluteRoot, change); err != nil {
+			return fmt.Errorf("applying change %d: %w", index+1, err)
+		}
+	}
+	return nil
+}
+
+func validateChange(root string, change FileChange) error {
+	if _, err := safePath(root, change.Path); err != nil {
+		return err
+	}
+	if change.MovePath != "" {
+		if _, err := safePath(root, change.MovePath); err != nil {
+			return fmt.Errorf("invalid move destination: %w", err)
+		}
+	}
+
+	switch change.Type {
+	case "add":
+		if change.UnifiedDiff != "" {
+			return errors.New("add change must not include a unified diff")
+		}
+	case "delete":
+	case "update":
+		if change.UnifiedDiff == "" {
+			return errors.New("update change is missing a unified diff")
+		}
+		if err := validateDiffPaths(root, change.UnifiedDiff); err != nil {
+			return err
+		}
+	default:
+		return fmt.Errorf("unsupported change type %q", change.Type)
+	}
+	return nil
+}
+
+func applyChange(ctx context.Context, root string, change FileChange) error {
+	path, err := safePath(root, change.Path)
+	if err != nil {
+		return err
+	}
+
+	switch change.Type {
+	case "add":
+		if err := os.MkdirAll(filepath.Dir(path), 0o700); err != nil {
+			return fmt.Errorf("creating parent directory: %w", err)
+		}
+		file, err := os.OpenFile(path, os.O_WRONLY|os.O_CREATE|os.O_EXCL, 0o600)
+		if err != nil {
+			return fmt.Errorf("creating added file: %w", err)
+		}
+		if _, err := file.WriteString(change.Content); err != nil {
+			file.Close()
+			return fmt.Errorf("writing added file: %w", err)
+		}
+		if err := file.Close(); err != nil {
+			return fmt.Errorf("closing added file: %w", err)
+		}
+	case "delete":
+		if err := os.Remove(path); err != nil {
+			return fmt.Errorf("deleting file: %w", err)
+		}
+	case "update":
+		command := exec.CommandContext(
+			ctx,
+			"git",
+			"-C",
+			root,
+			"apply",
+			"--whitespace=nowarn",
+			"-",
+		)
+		command.Stdin = strings.NewReader(change.UnifiedDiff)
+		var stderr bytes.Buffer
+		command.Stderr = &stderr
+		if err := command.Run(); err != nil {
+			return fmt.Errorf("applying unified diff: %w: %s", err, strings.TrimSpace(stderr.String()))
+		}
+		if change.MovePath != "" {
+			destination, err := safePath(root, change.MovePath)
+			if err != nil {
+				return err
+			}
+			if err := os.MkdirAll(filepath.Dir(destination), 0o700); err != nil {
+				return fmt.Errorf("creating move destination directory: %w", err)
+			}
+			if err := os.Rename(path, destination); err != nil {
+				return fmt.Errorf("moving updated file: %w", err)
+			}
+		}
+	}
+	return nil
+}
+
+func safePath(root, relative string) (string, error) {
+	if relative == "" || filepath.IsAbs(relative) {
+		return "", errors.New("path must be a non-empty relative path")
+	}
+
+	clean := filepath.Clean(relative)
+	if clean == "." || clean == ".." || strings.HasPrefix(clean, ".."+string(filepath.Separator)) {
+		return "", errors.New("path escapes replay root")
+	}
+	if clean == ".git" || strings.HasPrefix(clean, ".git"+string(filepath.Separator)) {
+		return "", errors.New("Git metadata paths are not allowed")
+	}
+
+	target := filepath.Join(root, clean)
+	relativeToRoot, err := filepath.Rel(root, target)
+	if err != nil || relativeToRoot == ".." ||
+		strings.HasPrefix(relativeToRoot, ".."+string(filepath.Separator)) {
+		return "", errors.New("path escapes replay root")
+	}
+
+	current := root
+	for _, component := range strings.Split(filepath.Dir(clean), string(filepath.Separator)) {
+		if component == "." || component == "" {
+			continue
+		}
+		current = filepath.Join(current, component)
+		info, err := os.Lstat(current)
+		if os.IsNotExist(err) {
+			break
+		}
+		if err != nil {
+			return "", fmt.Errorf("inspecting path component: %w", err)
+		}
+		if info.Mode()&os.ModeSymlink != 0 {
+			return "", errors.New("symlinked path components are not allowed")
+		}
+	}
+
+	return target, nil
+}
+
+func validateDiffPaths(root, diff string) error {
+	for line := range strings.SplitSeq(diff, "\n") {
+		if line == "new file mode 120000" || line == "new mode 120000" {
+			return errors.New("unified diff may not create symlinks")
+		}
+		if !strings.HasPrefix(line, "--- ") && !strings.HasPrefix(line, "+++ ") {
+			continue
+		}
+		path := strings.TrimSpace(line[4:])
+		path = strings.SplitN(path, "\t", 2)[0]
+		if path == "/dev/null" {
+			continue
+		}
+		path = strings.TrimPrefix(path, "a/")
+		path = strings.TrimPrefix(path, "b/")
+		if _, err := safePath(root, path); err != nil {
+			return fmt.Errorf("unsafe unified diff path: %w", err)
+		}
+	}
+	return nil
+}
diff --git a/internal/evidence/replay_test.go b/internal/evidence/replay_test.go
new file mode 100644
index 0000000..fd098ff
--- /dev/null
+++ b/internal/evidence/replay_test.go
@@ -0,0 +1,210 @@
+package evidence
+
+import (
+	"context"
+	"encoding/json"
+	"os"
+	"path/filepath"
+	"testing"
+)
+
+func TestExtractReplayPlanIncludesOrderedChangesThroughTargetTurn(t *testing.T) {
+	t.Parallel()
+
+	root := t.TempDir()
+	sessionPath := filepath.Join(root, "session.jsonl")
+	writeSession(t, root, "session.jsonl", []map[string]any{
+		event("session_meta", map[string]any{
+			"cwd": "/private/repository",
+			"git": map[string]any{"commit_hash": "base123"},
+		}),
+		event("event_msg", map[string]any{
+			"type":    "patch_apply_end",
+			"turn_id": "prior",
+			"success": true,
+			"changes": map[string]any{
+				"/private/repository/first.txt": map[string]any{
+					"type": "add", "content": "first\n",
+				},
+			},
+		}),
+		event("event_msg", map[string]any{
+			"type":    "patch_apply_end",
+			"turn_id": "target",
+			"success": true,
+			"changes": map[string]any{
+				"/private/repository/second.txt": map[string]any{
+					"type": "add", "content": "second\n",
+				},
+			},
+		}),
+		event("event_msg", map[string]any{"type": "task_complete", "turn_id": "target"}),
+		event("event_msg", map[string]any{
+			"type":    "patch_apply_end",
+			"turn_id": "later",
+			"success": true,
+			"changes": map[string]any{
+				"later.txt": map[string]any{"type": "add", "content": "later\n"},
+			},
+		}),
+	})
+
+	plan, err := ExtractReplayPlan(sessionPath, "target")
+	if err != nil {
+		t.Fatalf("ExtractReplayPlan() error = %v", err)
+	}
+
+	if plan.BaseCommit != "base123" {
+		t.Errorf("BaseCommit = %q, want base123", plan.BaseCommit)
+	}
+	if plan.RepositoryRoot != "/private/repository" {
+		t.Errorf("RepositoryRoot = %q, want /private/repository", plan.RepositoryRoot)
+	}
+	if len(plan.Changes) != 2 {
+		t.Fatalf("len(Changes) = %d, want 2", len(plan.Changes))
+	}
+	if plan.Changes[0].Path != "first.txt" || plan.Changes[1].Path != "second.txt" {
+		t.Errorf("change order = %q, %q", plan.Changes[0].Path, plan.Changes[1].Path)
+	}
+
+	encoded, err := json.Marshal(plan)
+	if err != nil {
+		t.Fatal(err)
+	}
+	if string(encoded) != "{}" {
+		t.Fatalf("encoded plan leaked reconstruction inputs: %s", encoded)
+	}
+}
+
+func TestExtractReplayPlanRejectsRecordedPathOutsideRepository(t *testing.T) {
+	t.Parallel()
+
+	root := t.TempDir()
+	sessionPath := filepath.Join(root, "session.jsonl")
+	writeSession(t, root, "session.jsonl", []map[string]any{
+		event("session_meta", map[string]any{
+			"cwd": "/private/repository",
+			"git": map[string]any{"commit_hash": "base123"},
+		}),
+		event("event_msg", map[string]any{
+			"type":    "patch_apply_end",
+			"turn_id": "target",
+			"success": true,
+			"changes": map[string]any{
+				"/private/other/escape.txt": map[string]any{
+					"type": "add", "content": "escape\n",
+				},
+			},
+		}),
+		event("event_msg", map[string]any{"type": "task_complete", "turn_id": "target"}),
+	})
+
+	if _, err := ExtractReplayPlan(sessionPath, "target"); err == nil {
+		t.Fatal("ExtractReplayPlan() error = nil, want outside-repository rejection")
+	}
+}
+
+func TestApplyChangesReconstructsOrderedFileState(t *testing.T) {
+	t.Parallel()
+
+	root := t.TempDir()
+	if err := os.WriteFile(filepath.Join(root, "existing.txt"), []byte("old\n"), 0o600); err != nil {
+		t.Fatal(err)
+	}
+	if err := os.WriteFile(filepath.Join(root, "obsolete.txt"), []byte("remove\n"), 0o600); err != nil {
+		t.Fatal(err)
+	}
+
+	changes := []FileChange{
+		{
+			Path: "existing.txt",
+			Type: "update",
+			UnifiedDiff: "diff --git a/existing.txt b/existing.txt\n" +
+				"--- a/existing.txt\n" +
+				"+++ b/existing.txt\n" +
+				"@@ -1 +1 @@\n" +
+				"-old\n" +
+				"+new\n",
+		},
+		{Path: "nested/added.txt", Type: "add", Content: "created\n"},
+		{Path: "obsolete.txt", Type: "delete"},
+	}
+
+	if err := ApplyChanges(context.Background(), root, changes); err != nil {
+		t.Fatalf("ApplyChanges() error = %v", err)
+	}
+
+	assertFileContent(t, filepath.Join(root, "existing.txt"), "new\n")
+	assertFileContent(t, filepath.Join(root, "nested/added.txt"), "created\n")
+	if _, err := os.Stat(filepath.Join(root, "obsolete.txt")); !os.IsNotExist(err) {
+		t.Fatalf("obsolete file still exists or stat failed unexpectedly: %v", err)
+	}
+}
+
+func TestApplyChangesRejectsUnsafePathsBeforeWriting(t *testing.T) {
+	t.Parallel()
+
+	root := t.TempDir()
+	sentinel := filepath.Join(root, "sentinel.txt")
+	if err := os.WriteFile(sentinel, []byte("unchanged\n"), 0o600); err != nil {
+		t.Fatal(err)
+	}
+
+	changes := []FileChange{
+		{Path: "safe.txt", Type: "add", Content: "must not be written\n"},
+		{Path: "../escape.txt", Type: "add", Content: "escaped\n"},
+	}
+
+	if err := ApplyChanges(context.Background(), root, changes); err == nil {
+		t.Fatal("ApplyChanges() error = nil, want unsafe path rejection")
+	}
+	if _, err := os.Stat(filepath.Join(root, "safe.txt")); !os.IsNotExist(err) {
+		t.Fatalf("safe change was applied before validation completed: %v", err)
+	}
+	assertFileContent(t, sentinel, "unchanged\n")
+}
+
+func TestApplyChangesRejectsGitMetadata(t *testing.T) {
+	t.Parallel()
+
+	root := t.TempDir()
+	err := ApplyChanges(context.Background(), root, []FileChange{
+		{Path: ".git/config", Type: "add", Content: "malicious\n"},
+	})
+	if err == nil {
+		t.Fatal("ApplyChanges() error = nil, want .git path rejection")
+	}
+}
+
+func TestApplyChangesRejectsDiffThatCreatesSymlink(t *testing.T) {
+	t.Parallel()
+
+	root := t.TempDir()
+	err := ApplyChanges(context.Background(), root, []FileChange{
+		{
+			Path: "escape",
+			Type: "update",
+			UnifiedDiff: "diff --git a/escape b/escape\n" +
+				"new file mode 120000\n" +
+				"--- /dev/null\n" +
+				"+++ b/escape\n" +
+				"@@ -0,0 +1 @@\n" +
+				"+../../outside\n",
+		},
+	})
+	if err == nil {
+		t.Fatal("ApplyChanges() error = nil, want symlink creation rejection")
+	}
+}
+
+func assertFileContent(t *testing.T, path, want string) {
+	t.Helper()
+
+	content, err := os.ReadFile(path)
+	if err != nil {
+		t.Fatal(err)
+	}
+	if string(content) != want {
+		t.Errorf("%s content = %q, want %q", filepath.Base(path), content, want)
+	}
+}
diff --git a/scripts/evidence-audit/main.go b/scripts/evidence-audit/main.go
new file mode 100644
index 0000000..237b30a
--- /dev/null
+++ b/scripts/evidence-audit/main.go
@@ -0,0 +1,73 @@
+// Command evidence-audit produces content-free aggregate metrics from local
+// agent history. It is a research utility, not part of the public GPTCode CLI.
+package main
+
+import (
+	"context"
+	"encoding/json"
+	"flag"
+	"fmt"
+	"os"
+
+	"github.com/jadercorrea/gptcode/internal/evidence"
+)
+
+func main() {
+	root := flag.String("codex-root", "", "path to the Codex sessions directory")
+	replaySession := flag.String("replay-session", "", "Codex JSONL session to replay")
+	replayTurn := flag.String("replay-turn", "", "turn ID to replay through")
+	replayRoot := flag.String("replay-root", "", "detached worktree receiving the replay")
+	flag.Parse()
+
+	if *replaySession != "" || *replayTurn != "" || *replayRoot != "" {
+		replay(context.Background(), *replaySession, *replayTurn, *replayRoot)
+		return
+	}
+	if *root == "" {
+		fmt.Fprintln(os.Stderr, "usage: evidence-audit -codex-root <directory>")
+		os.Exit(2)
+	}
+
+	summary, err := evidence.ScanCodex(*root)
+	if err != nil {
+		fmt.Fprintf(os.Stderr, "evidence audit failed: %v\n", err)
+		os.Exit(1)
+	}
+
+	encoder := json.NewEncoder(os.Stdout)
+	encoder.SetIndent("", "  ")
+	if err := encoder.Encode(summary); err != nil {
+		fmt.Fprintf(os.Stderr, "writing evidence audit: %v\n", err)
+		os.Exit(1)
+	}
+}
+
+func replay(ctx context.Context, sessionPath, turnID, root string) {
+	if sessionPath == "" || turnID == "" || root == "" {
+		fmt.Fprintln(
+			os.Stderr,
+			"replay requires -replay-session, -replay-turn, and -replay-root",
+		)
+		os.Exit(2)
+	}
+
+	plan, err := evidence.ExtractReplayPlan(sessionPath, turnID)
+	if err != nil {
+		fmt.Fprintln(os.Stderr, "extracting replay plan failed safely")
+		os.Exit(1)
+	}
+	if err := evidence.ApplyChanges(ctx, root, plan.Changes); err != nil {
+		fmt.Fprintln(os.Stderr, "applying replay plan failed safely")
+		os.Exit(1)
+	}
+
+	result := struct {
+		AppliedChanges int `json:"applied_changes"`
+	}{
+		AppliedChanges: len(plan.Changes),
+	}
+	if err := json.NewEncoder(os.Stdout).Encode(result); err != nil {
+		fmt.Fprintf(os.Stderr, "writing replay result: %v\n", err)
+		os.Exit(1)
+	}
+}

From 8fe858b81c72625c214308a8aa72f6d25d14c2cb Mon Sep 17 00:00:00 2001
From: Jader Correa <jadercorrea.hv@gmail.com>
Date: Tue, 28 Jul 2026 17:20:47 -0300
Subject: [PATCH 2/3] research: make local agents measurable

Local agent runs were not credible evidence: historical sessions lacked reproducible baselines, fresh runs hid progress until completion, Ollama used a fixed timeout, and retry budgets could be exhausted without measurable improvement. The same gaps made local execution slower, opaque, and easy to overstate.

Build deterministic, replayable evaluation bundles around clean fixtures; ground planning and retries in repository contracts; stream verbose stages while preserving captured output; tune Ollama timeout and context for available hardware; and stop equivalent verification plateaus early. Strengthened fixtures retain false positives and failures, while reviewed Qwen cache and Devstral filesystem results demonstrate bounded, zero-API-cost capability.

General reliability still requires repeatability across more fixtures. The Devstral filesystem result is one reviewed contract pass, and its generated patch is not claimed as a race-free filesystem primitive against an actively hostile concurrent process.
---
 _roadmap.md                                   |  12 +-
 benchmarks/README.md                          | 106 ++++
 .../fixtures/go-expiring-cache/cache.go       |  53 ++
 .../fixtures/go-expiring-cache/cache_test.go  |  67 +++
 benchmarks/fixtures/go-expiring-cache/go.mod  |   3 +
 .../go-expiring-cache/quality_test.go         |  22 +
 benchmarks/fixtures/go-expiring-cache/task.md |  16 +
 .../fixtures/go-ledger/concurrency_test.go    |  68 +++
 benchmarks/fixtures/go-ledger/go.mod          |   3 +
 benchmarks/fixtures/go-ledger/ledger.go       |  38 ++
 benchmarks/fixtures/go-ledger/ledger_test.go  |  33 ++
 benchmarks/fixtures/go-ledger/quality_test.go |  41 ++
 benchmarks/fixtures/go-ledger/task.md         |  17 +
 benchmarks/fixtures/go-safe-store/go.mod      |   3 +
 .../fixtures/go-safe-store/quality_test.go    |  22 +
 benchmarks/fixtures/go-safe-store/store.go    |  22 +
 .../fixtures/go-safe-store/store_test.go      | 109 ++++
 benchmarks/fixtures/go-safe-store/task.md     |  16 +
 benchmarks/results/2026-07-28-local-smoke.md  | 116 ++++
 .../results/2026-07-29-local-filesystem.md    |  93 ++++
 .../local-devstral-small-2-safe-store.json    |  43 ++
 benchmarks/suites/local-gpt-oss.json          |  69 +++
 .../suites/local-qwen3-coder-cache.json       |  39 ++
 benchmarks/suites/local-qwen3-coder.json      |  69 +++
 internal/agents/editor.go                     |  37 +-
 internal/agents/editor_test.go                | 110 +++-
 internal/agents/query.go                      |  12 +
 internal/agents/query_test.go                 |  30 +
 internal/autonomous/analyzer.go               |  52 +-
 internal/autonomous/movement_test.go          |  38 ++
 internal/config/model_selector.go             |  60 +-
 internal/config/model_selector_test.go        |  64 +++
 internal/evidence/bundle.go                   | 511 ++++++++++++++++++
 internal/evidence/bundle_test.go              | 232 ++++++++
 internal/evidence/suite.go                    | 309 +++++++++++
 internal/evidence/suite_test.go               | 224 ++++++++
 internal/llm/ollama.go                        |  47 +-
 internal/llm/ollama_test.go                   |  68 +++
 internal/maestro/conductor.go                 | 104 +++-
 internal/maestro/formatter.go                 |  63 +++
 internal/maestro/formatter_test.go            |  67 +++
 internal/maestro/repository_context.go        |  66 +++
 internal/maestro/repository_context_test.go   |  49 ++
 internal/maestro/verification_progress.go     |  55 ++
 .../maestro/verification_progress_test.go     |  57 ++
 internal/modes/model_selection.go             |   7 +
 internal/modes/model_selection_test.go        |  28 +
 internal/modes/research.go                    | 100 +++-
 internal/modes/research_test.go               |  49 ++
 internal/modes/review.go                      |  51 +-
 internal/modes/review_test.go                 |  33 ++
 internal/observability/observer.go            |  15 +-
 internal/observability/observer_test.go       |  23 +
 scripts/evidence-run/main.go                  |  48 ++
 scripts/evidence-suite/main.go                |  65 +++
 55 files changed, 3659 insertions(+), 95 deletions(-)
 create mode 100644 benchmarks/README.md
 create mode 100644 benchmarks/fixtures/go-expiring-cache/cache.go
 create mode 100644 benchmarks/fixtures/go-expiring-cache/cache_test.go
 create mode 100644 benchmarks/fixtures/go-expiring-cache/go.mod
 create mode 100644 benchmarks/fixtures/go-expiring-cache/quality_test.go
 create mode 100644 benchmarks/fixtures/go-expiring-cache/task.md
 create mode 100644 benchmarks/fixtures/go-ledger/concurrency_test.go
 create mode 100644 benchmarks/fixtures/go-ledger/go.mod
 create mode 100644 benchmarks/fixtures/go-ledger/ledger.go
 create mode 100644 benchmarks/fixtures/go-ledger/ledger_test.go
 create mode 100644 benchmarks/fixtures/go-ledger/quality_test.go
 create mode 100644 benchmarks/fixtures/go-ledger/task.md
 create mode 100644 benchmarks/fixtures/go-safe-store/go.mod
 create mode 100644 benchmarks/fixtures/go-safe-store/quality_test.go
 create mode 100644 benchmarks/fixtures/go-safe-store/store.go
 create mode 100644 benchmarks/fixtures/go-safe-store/store_test.go
 create mode 100644 benchmarks/fixtures/go-safe-store/task.md
 create mode 100644 benchmarks/results/2026-07-28-local-smoke.md
 create mode 100644 benchmarks/results/2026-07-29-local-filesystem.md
 create mode 100644 benchmarks/suites/local-devstral-small-2-safe-store.json
 create mode 100644 benchmarks/suites/local-gpt-oss.json
 create mode 100644 benchmarks/suites/local-qwen3-coder-cache.json
 create mode 100644 benchmarks/suites/local-qwen3-coder.json
 create mode 100644 internal/agents/query_test.go
 create mode 100644 internal/autonomous/movement_test.go
 create mode 100644 internal/evidence/bundle.go
 create mode 100644 internal/evidence/bundle_test.go
 create mode 100644 internal/evidence/suite.go
 create mode 100644 internal/evidence/suite_test.go
 create mode 100644 internal/llm/ollama_test.go
 create mode 100644 internal/maestro/formatter.go
 create mode 100644 internal/maestro/formatter_test.go
 create mode 100644 internal/maestro/verification_progress.go
 create mode 100644 internal/maestro/verification_progress_test.go
 create mode 100644 internal/modes/model_selection.go
 create mode 100644 internal/modes/model_selection_test.go
 create mode 100644 scripts/evidence-run/main.go
 create mode 100644 scripts/evidence-suite/main.go

diff --git a/_roadmap.md b/_roadmap.md
index ae183d9..258f7a1 100644
--- a/_roadmap.md
+++ b/_roadmap.md
@@ -40,5 +40,15 @@ engineering portfolio.
 - [ ] Isolate Live as an optional local observability protocol and retire unused training and experimental command surfaces.
 - [x] Build a content-free Codex history scanner and validate turn-level Git, patch, verification, and completion evidence against the local corpus.
 - [x] Build and container-validate a path-safe historical patch replayer, and establish that legacy Codex sessions lack the dirty-worktree baseline needed for deterministic replay.
-- [ ] Capture an initial base diff or snapshot in new sessions, prove deterministic replay end to end, then add an OpenCode importer to challenge the vendor-neutral evidence model.
+- [x] Capture complete initial and final snapshots for new agent experiments and prove deterministic bundle restoration end to end.
+- [x] Run a real local-model evaluation against a concurrent Go fixture and use its failures to fix local routing, repository-grounded planning, and retry context.
+- [x] Expand the evaluation corpus across concurrency, temporal semantics, and filesystem containment, with failure-inclusive suite aggregation and per-run time budgets.
+- [x] Compare GPT-OSS and Qwen3-Coder on the same smoke corpus, review the apparent pass, and strengthen the contract after identifying a false positive.
+- [x] Identify a local configuration that produces a human-reviewed fixture pass and measure three-run repeatability on the strengthened cache contract.
+- [x] Find a fully GPU-backed local configuration that passes the strengthened safe-store contract, while retaining Qwen's extended-budget failure as negative evidence.
+- [x] Stream verbose agent stages from the evidence suite without sacrificing the replayable output bundle.
+- [x] Measure Devstral safe-store repeatability and retain the 0/3 timeout result alongside the earlier reviewed capability pass.
+- [ ] Improve local safe-store convergence; neither Qwen nor Devstral currently supports a reliability claim on the strengthened contract.
+- [ ] Extend reviewed repeatability beyond one fixture before publishing a general coding-agent success-rate claim.
+- [ ] Add an OpenCode importer to challenge the vendor-neutral evidence model.
 - [ ] Raise coverage in legacy workflow packages without presenting the public fixture as repository-wide coverage.
diff --git a/benchmarks/README.md b/benchmarks/README.md
new file mode 100644
index 0000000..a3da318
--- /dev/null
+++ b/benchmarks/README.md
@@ -0,0 +1,106 @@
+# GPTCode agent evaluation
+
+The evaluation harness runs coding agents against the same clean Git fixture
+and records an inspectable evidence bundle. It is designed to answer a narrow
+question: did the agent produce a change that satisfies executable,
+task-specific checks without losing the initial repository state?
+
+An experiment configuration names the agent process explicitly. Commands are
+executed directly, without an implicit shell. The evidence directory must live
+outside the evaluated repository so the run cannot accidentally measure its
+own artifacts.
+
+```json
+{
+  "id": "go-ledger-deadlock",
+  "repository": "/tmp/go-ledger",
+  "output": "/tmp/go-ledger-evidence",
+  "agent": {
+    "name": "gptcode-local",
+    "args": [
+      "/Users/jadercorrea/bin/gt",
+      "do",
+      "Fix the opposing-transfer deadlock without changing the public API"
+    ]
+  },
+  "verifications": [
+    {
+      "name": "tests-and-race-detector",
+      "args": ["go", "test", "-race", "./..."]
+    },
+    {
+      "name": "static-analysis",
+      "args": ["go", "vet", "./..."]
+    }
+  ]
+}
+```
+
+Run it with:
+
+```bash
+go run ./scripts/evidence-run -config /tmp/experiment.json
+```
+
+Every result retains failures as evidence. A successful agent process does not
+make a run pass: every verification command must also exit successfully.
+
+## Repeatability suites
+
+The suite runner creates a fresh Git repository for every fixture repetition
+and aggregates all outcomes. It runs sequentially so local CPU and memory
+contention do not bias model comparisons.
+
+```bash
+go run ./scripts/evidence-suite \
+  -verbose \
+  -config benchmarks/suites/local-gpt-oss.json \
+  -output /tmp/gptcode-go-core-quality
+```
+
+`-verbose` streams the agent's inspectable stages while retaining identical
+stdout and stderr in the evidence bundle. It exposes model selection, planning,
+tool execution, retries, and deterministic checks; it does not print private
+model chain-of-thought.
+
+Use `benchmarks/suites/local-qwen3-coder.json` for the equivalent Qwen suite.
+Each committed local suite records and executes its required GPTCode profile
+selection in `setup.json`; the agent name is not merely a user-supplied label.
+`benchmarks/suites/local-qwen3-coder-cache.json` preserves the first
+human-reviewed three-run result on the strengthened cache contract.
+`benchmarks/suites/local-devstral-small-2-safe-store.json` records the
+hardware-tuned 16k Devstral configuration that produced the first reviewed
+pass on strengthened filesystem containment.
+
+The initial corpus covers three distinct failure classes:
+
+- lock ordering and deterministic concurrency;
+- TTL boundary semantics under concurrent cache access;
+- path traversal and symlink containment at a filesystem boundary.
+
+The committed suite uses three repetitions. During harness development,
+`-repetitions 1` provides a smoke test without presenting it as a consistency
+measurement. `run_timeout_seconds` is a hard agent budget; verification still
+runs after a timeout so the resulting repository state remains evidence.
+Fixtures with `require_failing_baseline` also write `baseline.json` and abort
+the suite if every check already passes before the agent runs.
+
+Development results are recorded under `benchmarks/results/`. They distinguish
+system defects from model failures and never promote a one-run smoke test to a
+repeatability claim.
+
+## Bundle contract
+
+The generated directory contains:
+
+- `manifest.json`: schema, base commit, timestamps, and snapshot hashes.
+- `initial.tar` and `final.tar`: deterministic repository snapshots excluding
+  Git metadata.
+- `initial.patch`, `agent.patch`, and `final.patch`: binary-capable Git diffs.
+- `events.jsonl`: lifecycle events.
+- `commands.jsonl`: exact commands, outputs, exit codes, and durations.
+- `verification.json`: the machine-readable pass/fail decision.
+- `report.md`: a compact human-readable summary.
+
+Snapshots are intentionally complete. Only use controlled public fixtures:
+real repositories may contain credentials or proprietary untracked files.
diff --git a/benchmarks/fixtures/go-expiring-cache/cache.go b/benchmarks/fixtures/go-expiring-cache/cache.go
new file mode 100644
index 0000000..71564b0
--- /dev/null
+++ b/benchmarks/fixtures/go-expiring-cache/cache.go
@@ -0,0 +1,53 @@
+package expiringcache
+
+import (
+	"sync"
+	"time"
+)
+
+type entry struct {
+	value     string
+	expiresAt time.Time
+}
+
+type Cache struct {
+	mu      sync.RWMutex
+	entries map[string]entry
+	now     func() time.Time
+}
+
+func New() *Cache {
+	return newWithClock(time.Now)
+}
+
+func newWithClock(now func() time.Time) *Cache {
+	return &Cache{
+		entries: make(map[string]entry),
+		now:     now,
+	}
+}
+
+func (c *Cache) Set(key, value string, ttl time.Duration) {
+	c.mu.Lock()
+	defer c.mu.Unlock()
+	c.entries[key] = entry{
+		value:     value,
+		expiresAt: c.now().Add(ttl),
+	}
+}
+
+func (c *Cache) Get(key string) (string, bool) {
+	c.mu.RLock()
+	defer c.mu.RUnlock()
+	item, found := c.entries[key]
+	if !found {
+		return "", false
+	}
+	return item.value, true
+}
+
+func (c *Cache) Len() int {
+	c.mu.RLock()
+	defer c.mu.RUnlock()
+	return len(c.entries)
+}
diff --git a/benchmarks/fixtures/go-expiring-cache/cache_test.go b/benchmarks/fixtures/go-expiring-cache/cache_test.go
new file mode 100644
index 0000000..b65ef28
--- /dev/null
+++ b/benchmarks/fixtures/go-expiring-cache/cache_test.go
@@ -0,0 +1,67 @@
+package expiringcache
+
+import (
+	"sync"
+	"testing"
+	"time"
+)
+
+func TestGetReturnsLiveEntry(t *testing.T) {
+	now := time.Date(2026, time.July, 28, 12, 0, 0, 0, time.UTC)
+	cache := newWithClock(func() time.Time { return now })
+	cache.Set("session", "active", time.Minute)
+
+	value, found := cache.Get("session")
+	if !found || value != "active" {
+		t.Fatalf("Get() = %q, %v, want active, true", value, found)
+	}
+}
+
+func TestGetEvictsExpiredEntry(t *testing.T) {
+	now := time.Date(2026, time.July, 28, 12, 0, 0, 0, time.UTC)
+	cache := newWithClock(func() time.Time { return now })
+	cache.Set("session", "expired", time.Minute)
+	now = now.Add(time.Minute)
+
+	if value, found := cache.Get("session"); found || value != "" {
+		t.Fatalf("Get() = %q, %v, want empty, false", value, found)
+	}
+	if length := cache.Len(); length != 0 {
+		t.Fatalf("Len() = %d, want expired entry removed", length)
+	}
+}
+
+func TestLenPurgesExpiredEntriesWithoutLookup(t *testing.T) {
+	now := time.Date(2026, time.July, 28, 12, 0, 0, 0, time.UTC)
+	cache := newWithClock(func() time.Time { return now })
+	cache.Set("expired", "stale", time.Minute)
+	cache.Set("live", "current", 2*time.Minute)
+	now = now.Add(time.Minute)
+
+	if length := cache.Len(); length != 1 {
+		t.Fatalf("Len() = %d, want only the live entry", length)
+	}
+	if value, found := cache.Get("live"); !found || value != "current" {
+		t.Fatalf("Get(live) = %q, %v, want current, true", value, found)
+	}
+}
+
+func TestCacheSupportsConcurrentReadersAndWriters(t *testing.T) {
+	cache := New()
+	var workers sync.WaitGroup
+	for worker := range 8 {
+		workers.Add(1)
+		go func() {
+			defer workers.Done()
+			for iteration := range 250 {
+				key := string(rune('a' + worker))
+				cache.Set(key, "value", time.Minute)
+				cache.Get(key)
+				if iteration%10 == 0 {
+					cache.Len()
+				}
+			}
+		}()
+	}
+	workers.Wait()
+}
diff --git a/benchmarks/fixtures/go-expiring-cache/go.mod b/benchmarks/fixtures/go-expiring-cache/go.mod
new file mode 100644
index 0000000..6926ffb
--- /dev/null
+++ b/benchmarks/fixtures/go-expiring-cache/go.mod
@@ -0,0 +1,3 @@
+module example.com/expiringcache
+
+go 1.22
diff --git a/benchmarks/fixtures/go-expiring-cache/quality_test.go b/benchmarks/fixtures/go-expiring-cache/quality_test.go
new file mode 100644
index 0000000..39f8ea9
--- /dev/null
+++ b/benchmarks/fixtures/go-expiring-cache/quality_test.go
@@ -0,0 +1,22 @@
+package expiringcache
+
+import (
+	"bytes"
+	"go/format"
+	"os"
+	"testing"
+)
+
+func TestCacheImplementationIsFormatted(t *testing.T) {
+	source, err := os.ReadFile("cache.go")
+	if err != nil {
+		t.Fatal(err)
+	}
+	formatted, err := format.Source(source)
+	if err != nil {
+		t.Fatalf("format.Source() error = %v", err)
+	}
+	if !bytes.Equal(source, formatted) {
+		t.Fatal("cache.go is not gofmt-formatted")
+	}
+}
diff --git a/benchmarks/fixtures/go-expiring-cache/task.md b/benchmarks/fixtures/go-expiring-cache/task.md
new file mode 100644
index 0000000..b2ae0ef
--- /dev/null
+++ b/benchmarks/fixtures/go-expiring-cache/task.md
@@ -0,0 +1,16 @@
+# Enforce cache expiration
+
+`Cache.Get` currently returns entries after their TTL has elapsed, and `Len`
+continues to count those stale entries.
+
+Make expiration authoritative while preserving the exported API. A lookup at
+the exact expiration instant is expired and must remove the stale entry.
+Maintain race-free concurrent reads and writes; do not introduce background
+goroutines or wall-clock sleeps.
+
+The implementation must pass:
+
+```text
+go test -race ./...
+go vet ./...
+```
diff --git a/benchmarks/fixtures/go-ledger/concurrency_test.go b/benchmarks/fixtures/go-ledger/concurrency_test.go
new file mode 100644
index 0000000..b87f599
--- /dev/null
+++ b/benchmarks/fixtures/go-ledger/concurrency_test.go
@@ -0,0 +1,68 @@
+package ledger
+
+import (
+	"sync"
+	"testing"
+	"time"
+)
+
+func TestSelfTransferCompletes(t *testing.T) {
+	account := NewAccount(1_000)
+	completed := make(chan error, 1)
+	go func() {
+		completed <- Transfer(account, account, 10)
+	}()
+
+	select {
+	case err := <-completed:
+		if err != nil {
+			t.Fatalf("Transfer() error = %v", err)
+		}
+	case <-time.After(250 * time.Millisecond):
+		t.Fatal("self-transfer deadlocked")
+	}
+
+	if balance := account.Balance(); balance != 1_000 {
+		t.Errorf("balance = %d, want 1000", balance)
+	}
+}
+
+func TestOpposingTransfersComplete(t *testing.T) {
+	left := NewAccount(1_000)
+	right := NewAccount(1_000)
+	start := make(chan struct{})
+	var workers sync.WaitGroup
+	workers.Add(2)
+
+	go func() {
+		defer workers.Done()
+		<-start
+		for range 1_000 {
+			_ = Transfer(left, right, 1)
+		}
+	}()
+	go func() {
+		defer workers.Done()
+		<-start
+		for range 1_000 {
+			_ = Transfer(right, left, 1)
+		}
+	}()
+
+	close(start)
+	completed := make(chan struct{})
+	go func() {
+		workers.Wait()
+		close(completed)
+	}()
+
+	select {
+	case <-completed:
+	case <-time.After(2 * time.Second):
+		t.Fatal("opposing transfers deadlocked")
+	}
+
+	if total := left.Balance() + right.Balance(); total != 2_000 {
+		t.Errorf("total balance = %d, want 2000", total)
+	}
+}
diff --git a/benchmarks/fixtures/go-ledger/go.mod b/benchmarks/fixtures/go-ledger/go.mod
new file mode 100644
index 0000000..4bb9136
--- /dev/null
+++ b/benchmarks/fixtures/go-ledger/go.mod
@@ -0,0 +1,3 @@
+module example.com/ledger
+
+go 1.22
diff --git a/benchmarks/fixtures/go-ledger/ledger.go b/benchmarks/fixtures/go-ledger/ledger.go
new file mode 100644
index 0000000..3598890
--- /dev/null
+++ b/benchmarks/fixtures/go-ledger/ledger.go
@@ -0,0 +1,38 @@
+package ledger
+
+import (
+	"errors"
+	"sync"
+)
+
+var ErrInsufficientFunds = errors.New("insufficient funds")
+
+type Account struct {
+	mu      sync.Mutex
+	balance int
+}
+
+func NewAccount(balance int) *Account {
+	return &Account{balance: balance}
+}
+
+func (a *Account) Balance() int {
+	a.mu.Lock()
+	defer a.mu.Unlock()
+	return a.balance
+}
+
+// Transfer moves funds while preserving the total held by both accounts.
+func Transfer(from, to *Account, amount int) error {
+	from.mu.Lock()
+	defer from.mu.Unlock()
+	to.mu.Lock()
+	defer to.mu.Unlock()
+
+	if from.balance < amount {
+		return ErrInsufficientFunds
+	}
+	from.balance -= amount
+	to.balance += amount
+	return nil
+}
diff --git a/benchmarks/fixtures/go-ledger/ledger_test.go b/benchmarks/fixtures/go-ledger/ledger_test.go
new file mode 100644
index 0000000..251e47d
--- /dev/null
+++ b/benchmarks/fixtures/go-ledger/ledger_test.go
@@ -0,0 +1,33 @@
+package ledger
+
+import (
+	"errors"
+	"testing"
+)
+
+func TestTransfer(t *testing.T) {
+	from := NewAccount(100)
+	to := NewAccount(25)
+
+	if err := Transfer(from, to, 40); err != nil {
+		t.Fatalf("Transfer() error = %v", err)
+	}
+	if got := from.Balance(); got != 60 {
+		t.Errorf("source balance = %d, want 60", got)
+	}
+	if got := to.Balance(); got != 65 {
+		t.Errorf("destination balance = %d, want 65", got)
+	}
+}
+
+func TestTransferRejectsInsufficientFunds(t *testing.T) {
+	from := NewAccount(10)
+	to := NewAccount(20)
+
+	if err := Transfer(from, to, 11); !errors.Is(err, ErrInsufficientFunds) {
+		t.Fatalf("Transfer() error = %v, want ErrInsufficientFunds", err)
+	}
+	if got := from.Balance() + to.Balance(); got != 30 {
+		t.Errorf("total balance = %d, want 30", got)
+	}
+}
diff --git a/benchmarks/fixtures/go-ledger/quality_test.go b/benchmarks/fixtures/go-ledger/quality_test.go
new file mode 100644
index 0000000..998c6cd
--- /dev/null
+++ b/benchmarks/fixtures/go-ledger/quality_test.go
@@ -0,0 +1,41 @@
+package ledger
+
+import (
+	"bytes"
+	"go/format"
+	"go/parser"
+	"go/token"
+	"os"
+	"strconv"
+	"testing"
+)
+
+func TestLedgerImplementationIsFormatted(t *testing.T) {
+	source, err := os.ReadFile("ledger.go")
+	if err != nil {
+		t.Fatal(err)
+	}
+	formatted, err := format.Source(source)
+	if err != nil {
+		t.Fatalf("format.Source() error = %v", err)
+	}
+	if !bytes.Equal(source, formatted) {
+		t.Fatal("ledger.go is not gofmt-formatted")
+	}
+}
+
+func TestLedgerImplementationAvoidsUnsafe(t *testing.T) {
+	file, err := parser.ParseFile(token.NewFileSet(), "ledger.go", nil, parser.ImportsOnly)
+	if err != nil {
+		t.Fatal(err)
+	}
+	for _, imported := range file.Imports {
+		path, err := strconv.Unquote(imported.Path.Value)
+		if err != nil {
+			t.Fatal(err)
+		}
+		if path == "unsafe" {
+			t.Fatal("ledger.go must not depend on package unsafe for lock ordering")
+		}
+	}
+}
diff --git a/benchmarks/fixtures/go-ledger/task.md b/benchmarks/fixtures/go-ledger/task.md
new file mode 100644
index 0000000..8d39fd4
--- /dev/null
+++ b/benchmarks/fixtures/go-ledger/task.md
@@ -0,0 +1,17 @@
+# Eliminate opposing-transfer deadlocks
+
+Two goroutines transferring funds in opposite directions can each hold one
+account lock while waiting forever for the other. A transfer to the same
+account deterministically attempts to lock the same mutex twice.
+
+Fix both deadlocks while preserving the existing exported API, error semantics,
+and total balance. Keep the implementation idiomatic, `gofmt`-formatted, and
+do not use package `unsafe`. The provided regression and quality tests must
+pass:
+
+```text
+go test -race ./...
+go vet ./...
+```
+
+Do not weaken or remove synchronization.
diff --git a/benchmarks/fixtures/go-safe-store/go.mod b/benchmarks/fixtures/go-safe-store/go.mod
new file mode 100644
index 0000000..a05a534
--- /dev/null
+++ b/benchmarks/fixtures/go-safe-store/go.mod
@@ -0,0 +1,3 @@
+module example.com/safestore
+
+go 1.22
diff --git a/benchmarks/fixtures/go-safe-store/quality_test.go b/benchmarks/fixtures/go-safe-store/quality_test.go
new file mode 100644
index 0000000..c368717
--- /dev/null
+++ b/benchmarks/fixtures/go-safe-store/quality_test.go
@@ -0,0 +1,22 @@
+package safestore
+
+import (
+	"bytes"
+	"go/format"
+	"os"
+	"testing"
+)
+
+func TestStoreImplementationIsFormatted(t *testing.T) {
+	source, err := os.ReadFile("store.go")
+	if err != nil {
+		t.Fatal(err)
+	}
+	formatted, err := format.Source(source)
+	if err != nil {
+		t.Fatalf("format.Source() error = %v", err)
+	}
+	if !bytes.Equal(source, formatted) {
+		t.Fatal("store.go is not gofmt-formatted")
+	}
+}
diff --git a/benchmarks/fixtures/go-safe-store/store.go b/benchmarks/fixtures/go-safe-store/store.go
new file mode 100644
index 0000000..5c02463
--- /dev/null
+++ b/benchmarks/fixtures/go-safe-store/store.go
@@ -0,0 +1,22 @@
+package safestore
+
+import (
+	"os"
+	"path/filepath"
+)
+
+type Store struct {
+	root string
+}
+
+func New(root string) *Store {
+	return &Store{root: root}
+}
+
+func (s *Store) Write(name string, content []byte) error {
+	path := filepath.Join(s.root, name)
+	if err := os.MkdirAll(filepath.Dir(path), 0o700); err != nil {
+		return err
+	}
+	return os.WriteFile(path, content, 0o600)
+}
diff --git a/benchmarks/fixtures/go-safe-store/store_test.go b/benchmarks/fixtures/go-safe-store/store_test.go
new file mode 100644
index 0000000..5564b7a
--- /dev/null
+++ b/benchmarks/fixtures/go-safe-store/store_test.go
@@ -0,0 +1,109 @@
+package safestore
+
+import (
+	"errors"
+	"os"
+	"path/filepath"
+	"testing"
+)
+
+func TestWriteStoresNestedFileInsideRoot(t *testing.T) {
+	root := t.TempDir()
+	store := New(root)
+
+	if err := store.Write("reports/summary.txt", []byte("verified\n")); err != nil {
+		t.Fatalf("Write() error = %v", err)
+	}
+	content, err := os.ReadFile(filepath.Join(root, "reports", "summary.txt"))
+	if err != nil {
+		t.Fatal(err)
+	}
+	if string(content) != "verified\n" {
+		t.Fatalf("content = %q", content)
+	}
+}
+
+func TestWriteAllowsDotsInsidePathSegment(t *testing.T) {
+	root := t.TempDir()
+	store := New(root)
+
+	name := "reports/v1..v2.txt"
+	if err := store.Write(name, []byte("valid\n")); err != nil {
+		t.Fatalf("Write() error = %v for legitimate name", err)
+	}
+	content, err := os.ReadFile(filepath.Join(root, filepath.FromSlash(name)))
+	if err != nil {
+		t.Fatal(err)
+	}
+	if string(content) != "valid\n" {
+		t.Fatalf("content = %q", content)
+	}
+}
+
+func TestWriteRejectsTraversal(t *testing.T) {
+	parent := t.TempDir()
+	parent, err := filepath.EvalSymlinks(parent)
+	if err != nil {
+		t.Fatal(err)
+	}
+	root := filepath.Join(parent, "store")
+	if err := os.Mkdir(root, 0o700); err != nil {
+		t.Fatal(err)
+	}
+	store := New(root)
+
+	err = store.Write("../escaped.txt", []byte("escape"))
+	if err == nil {
+		t.Fatal("Write() error = nil, want traversal rejection")
+	}
+	if _, statErr := os.Stat(filepath.Join(parent, "escaped.txt")); !errors.Is(statErr, os.ErrNotExist) {
+		t.Fatalf("file escaped root: %v", statErr)
+	}
+}
+
+func TestWriteRejectsTraversalAfterNormalizingSegments(t *testing.T) {
+	parent := t.TempDir()
+	parent, err := filepath.EvalSymlinks(parent)
+	if err != nil {
+		t.Fatal(err)
+	}
+	root := filepath.Join(parent, "store")
+	if err := os.Mkdir(root, 0o700); err != nil {
+		t.Fatal(err)
+	}
+	store := New(root)
+
+	err = store.Write("reports/../../escaped.txt", []byte("escape"))
+	if err == nil {
+		t.Fatal("Write() error = nil, want normalized traversal rejection")
+	}
+	if _, statErr := os.Stat(filepath.Join(parent, "escaped.txt")); !errors.Is(statErr, os.ErrNotExist) {
+		t.Fatalf("file escaped root: %v", statErr)
+	}
+}
+
+func TestWriteRejectsAbsolutePath(t *testing.T) {
+	root := t.TempDir()
+	store := New(root)
+
+	if err := store.Write(filepath.Join(t.TempDir(), "escaped.txt"), []byte("escape")); err == nil {
+		t.Fatal("Write() error = nil, want absolute path rejection")
+	}
+}
+
+func TestWriteRejectsSymlinkedParent(t *testing.T) {
+	root := t.TempDir()
+	outside := t.TempDir()
+	if err := os.Symlink(outside, filepath.Join(root, "linked")); err != nil {
+		t.Fatal(err)
+	}
+	store := New(root)
+
+	err := store.Write("linked/escaped.txt", []byte("escape"))
+	if err == nil {
+		t.Fatal("Write() error = nil, want symlink rejection")
+	}
+	if _, statErr := os.Stat(filepath.Join(outside, "escaped.txt")); !errors.Is(statErr, os.ErrNotExist) {
+		t.Fatalf("file escaped through symlink: %v", statErr)
+	}
+}
diff --git a/benchmarks/fixtures/go-safe-store/task.md b/benchmarks/fixtures/go-safe-store/task.md
new file mode 100644
index 0000000..60ee6ca
--- /dev/null
+++ b/benchmarks/fixtures/go-safe-store/task.md
@@ -0,0 +1,16 @@
+# Contain writes inside the store root
+
+`Store.Write` accepts attacker-controlled names. Traversal, absolute paths, and
+symlinked parent directories can currently write outside the configured root.
+
+Contain every write beneath the root while preserving the exported API and
+support for legitimate nested paths. Reject unsafe input before creating
+directories or files. Do not resolve the problem by deleting symlinks, changing
+the process working directory, or weakening file permissions.
+
+The implementation must pass:
+
+```text
+go test -race ./...
+go vet ./...
+```
diff --git a/benchmarks/results/2026-07-28-local-smoke.md b/benchmarks/results/2026-07-28-local-smoke.md
new file mode 100644
index 0000000..cd13283
--- /dev/null
+++ b/benchmarks/results/2026-07-28-local-smoke.md
@@ -0,0 +1,116 @@
+# Local GPT-OSS smoke evaluation — 2026-07-28
+
+This is a development smoke test, not a benchmark claim. Each fixture ran once;
+repeatability requires the three repetitions declared by the suite.
+
+## Corpus
+
+| Fixture | Failure class | Deterministic contract |
+| --- | --- | --- |
+| `ledger-deadlock` | lock ordering and self-deadlock | tests, race detector, formatting, no `unsafe`, vet |
+| `cache-expiration` | TTL boundary and stale eviction | tests, race detector, formatting, vet |
+| `safe-store` | traversal and symlink containment | tests, race detector, formatting, vet |
+
+## First smoke
+
+The first run exposed harness and CLI defects before it could measure the model
+fairly:
+
+- a planner stage escaped the local profile and attempted OpenRouter;
+- structured `required_files` output could not be decoded;
+- Go formatting remained probabilistic.
+
+Result: **0/3 passed**, median duration **1m57s**. These runs remain preserved
+locally, but are not treated as model-performance evidence.
+
+## Corrected smoke
+
+The CLI was rebuilt with:
+
+- a hard prohibition on cloud backends in local mode;
+- support for string and structured movement file references;
+- deterministic `gofmt` on modified Go files before verification.
+
+| Fixture | Result | Duration | Final failure |
+| --- | ---: | ---: | --- |
+| `ledger-deadlock` | failed | 7m38s | invalid imports and unresolved `unsafe` reference |
+| `cache-expiration` | failed | 5m50s | `Len` still counted the expired entry |
+| `safe-store` | failed | 5m31s | malformed final source after retries |
+
+Corrected result: **0/3 passed**, median duration **5m50s**.
+
+No corrected run contacted OpenRouter. The model identified each root cause and
+made relevant edits, but did not converge to a verified implementation within
+three attempts. The current evidence therefore supports local exercisability,
+not acceptable coding-agent reliability.
+
+## Next measurement
+
+Do not publish a comparative success-rate claim yet. First:
+
+1. enforce the ten-minute per-run budget in the suite;
+2. test a faster local model on the same corpus;
+3. run all three repetitions only for configurations that pass at least one
+   smoke fixture;
+4. publish every run, including failures and timeouts.
+
+## Qwen3-Coder comparison
+
+The same corrected 1×3 smoke was run with `qwen3-coder:latest`.
+
+| Fixture | Initial result | Duration |
+| --- | ---: | ---: |
+| `ledger-deadlock` | failed | 1m38s |
+| `cache-expiration` | failed | 1m41s |
+| `safe-store` | passed contract | 1m51s |
+
+Initial aggregate: **1/3 passed**, median **1m41s**. This was substantially
+faster than GPT-OSS, but human review found that the safe-store implementation
+rejected every name containing `..`, including the legitimate
+`reports/v1..v2.txt`.
+
+The contract was strengthened to preserve dots inside ordinary path segments.
+A new Qwen safe-store run then failed in **1m35s** after three attempts.
+Therefore the earlier pass is classified as a contract false positive, not a
+quality-confirmed success.
+
+That conclusion changed after closing the editor feedback loop.
+
+## Grounded closed-loop Qwen result
+
+The CLI previously stopped the editor as soon as every planned file had been
+touched. It also omitted tests and `task.md` from planning and retry context.
+The corrected loop now:
+
+- grounds the initial plan and retries in implementation, tests, and task
+  constraints;
+- lets the editor run verification and repair the same file within one turn;
+- permits up to twenty tool calls for inspect → edit → verify → repair;
+- rejects empty local-model answers and propagates Ollama HTTP errors.
+
+Human review found two more fixture weaknesses before accepting a result:
+
+- safe-store traversal appeared to pass only because `/var` is a symlink on
+  macOS; the strengthened test resolves the temporary root first;
+- cache `Len` was not required to purge expired entries unless `Get` had
+  already been called; the strengthened test now checks independent cleanup.
+
+Qwen did not solve the strengthened safe-store contract within the ten-minute
+budget. It did solve the strengthened cache contract, and three clean
+repetitions produced:
+
+| Repetition | Result | Duration |
+| --- | ---: | ---: |
+| 1 | passed | 4m07s |
+| 2 | passed | 3m56s |
+| 3 | passed | 4m46s |
+
+Reviewed aggregate: **3/3 passed**, median **4m07s**, with `go test -race ./...`
+and `go vet ./...` passing after every agent run. The three patches used
+different locking strategies but all preserved the exported API, treated the
+exact TTL boundary as expired, and purged stale entries through both `Get` and
+`Len`.
+
+This is evidence of repeatability for one bounded temporal/concurrency task,
+not a general coding-agent success-rate claim. Filesystem containment remains
+an observed failure class.
diff --git a/benchmarks/results/2026-07-29-local-filesystem.md b/benchmarks/results/2026-07-29-local-filesystem.md
new file mode 100644
index 0000000..5d116e9
--- /dev/null
+++ b/benchmarks/results/2026-07-29-local-filesystem.md
@@ -0,0 +1,93 @@
+# Local filesystem-containment evaluation — 2026-07-29
+
+This development evaluation compares local configurations on the strengthened
+`safe-store` fixture. It is a single-run capability check, not a repeatability
+or general success-rate claim.
+
+## Hardware and execution
+
+- Apple M1 Pro, 16 GPU cores, 32 GB unified memory.
+- Ollama served every measured inference locally.
+- `ollama ps` reported Qwen at 24 GB and **100% GPU** with a 65,536-token
+  context.
+- Devstral Small 2 used 25 GB at 65,536 tokens and offloaded 8% to CPU.
+- Setting `GPTCODE_OLLAMA_CONTEXT_LENGTH=16384` reduced Devstral to 17 GB and
+  kept it at **100% GPU**.
+
+Kimi was not evaluated locally. Current Kimi releases do not fit this hardware
+as a comparable fully local coding-agent configuration.
+
+## Adaptive retry budget
+
+The CLI now stops after three equivalent deterministic-verification failures.
+Timing noise is normalized before comparison, while a changed failure resets
+the counter. This permits larger local-model budgets without spending every
+attempt on a demonstrated plateau.
+
+Qwen received 30 minutes and eight allowed attempts. It stopped after six
+attempts in **16m27s** when the symlink-parent failure repeated three times.
+More time did not resolve the strengthened contract.
+
+## Devstral calibration
+
+The first Devstral run exposed a fixed 120-second Ollama client timeout before
+the model could edit. The provider now defaults to ten minutes per request and
+supports:
+
+- `GPTCODE_OLLAMA_TIMEOUT`, parsed as a Go duration;
+- `GPTCODE_OLLAMA_CONTEXT_LENGTH`, sent to Ollama as `num_ctx`.
+
+At 32k, Devstral remained fully GPU-backed but timed out at 30 minutes after
+repeating an incorrect `EvalSymlinks` strategy and entering a no-diff tool
+loop.
+
+At 16k, Devstral completed in **26m08s**:
+
+| Gate | Result |
+| --- | ---: |
+| Agent exit | passed |
+| `go test -count=1 -race ./...` | passed |
+| `go vet ./...` | passed |
+| Files modified | 1 |
+| API cost | $0 |
+
+The first edit failed only the symlinked-parent test. The second edit passed
+the deterministic contract. The evidence suite streamed the verbose execution
+while preserving the same stdout and stderr in `commands.jsonl`.
+
+## Human review
+
+The Devstral patch correctly rejects the fixture's traversal, absolute-path,
+and pre-existing symlink cases while permitting nested paths and ordinary dots
+inside path segments.
+
+It is not presented as a general production filesystem primitive. Its
+symlink check and subsequent write are separate operations, leaving a TOCTOU
+window under a concurrently hostile filesystem. The result proves the bounded
+fixture contract, not race-free containment against an active attacker.
+
+One reviewed pass justifies further repetition. It does not justify a general
+model reliability claim.
+
+## Three-run repeatability result
+
+The same committed 16k configuration was then run three times from clean
+fixtures with a 30-minute budget per run.
+
+| Repetition | Result | Duration | Final observed failure |
+| --- | ---: | ---: | --- |
+| 1 | timed out | 30m01s | legitimate nested paths rejected |
+| 2 | timed out | 30m01s | legitimate nested paths rejected |
+| 3 | timed out | 30m01s | absolute path and symlink escape accepted |
+
+Repeatability result: **0/3 passed**, median **30m01s**.
+
+All three runs remained fully local and GPU-backed. They produced relevant
+edits, but did not converge before the task budget. The earlier reviewed pass
+remains evidence that this configuration can solve the bounded contract; the
+repeatability suite is stronger evidence that it cannot yet do so reliably.
+
+The runs also exposed nondeterministic Go temporary-directory IDs in otherwise
+equivalent test failures. The plateau detector now normalizes those paths so
+future local runs do not mistake ephemeral filesystem names for engineering
+progress.
diff --git a/benchmarks/suites/local-devstral-small-2-safe-store.json b/benchmarks/suites/local-devstral-small-2-safe-store.json
new file mode 100644
index 0000000..7f3a08c
--- /dev/null
+++ b/benchmarks/suites/local-devstral-small-2-safe-store.json
@@ -0,0 +1,43 @@
+{
+  "id": "go-safe-store-devstral-small-2",
+  "output": "/tmp/gptcode-devstral-small-2-safe-store",
+  "repetitions": 1,
+  "run_timeout_seconds": 1800,
+  "setup": [
+    {
+      "name": "select-local-devstral-profile",
+      "args": ["gt", "profiles", "use", "local.devstral"]
+    }
+  ],
+  "agent": {
+    "name": "gptcode-local-devstral-small-2-16k",
+    "args": [
+      "/usr/bin/env",
+      "GPTCODE_OLLAMA_CONTEXT_LENGTH=16384",
+      "GPTCODE_OLLAMA_TIMEOUT=6m",
+      "gt",
+      "do",
+      "Read task.md, implement the requested fix, and meet every regression and quality constraint in the repository.",
+      "--verbose",
+      "--max-attempts",
+      "8"
+    ]
+  },
+  "fixtures": [
+    {
+      "id": "safe-store",
+      "source": "benchmarks/fixtures/go-safe-store",
+      "require_failing_baseline": true,
+      "verifications": [
+        {
+          "name": "tests-race-and-quality-contract",
+          "args": ["go", "test", "-count=1", "-race", "./..."]
+        },
+        {
+          "name": "static-analysis",
+          "args": ["go", "vet", "./..."]
+        }
+      ]
+    }
+  ]
+}
diff --git a/benchmarks/suites/local-gpt-oss.json b/benchmarks/suites/local-gpt-oss.json
new file mode 100644
index 0000000..1251e37
--- /dev/null
+++ b/benchmarks/suites/local-gpt-oss.json
@@ -0,0 +1,69 @@
+{
+  "id": "go-core-quality",
+  "output": "/tmp/gptcode-go-core-quality",
+  "repetitions": 3,
+  "run_timeout_seconds": 600,
+  "setup": [
+    {
+      "name": "select-local-gpt-oss-profile",
+      "args": ["gt", "profiles", "use", "local.gptoss"]
+    }
+  ],
+  "agent": {
+    "name": "gptcode-local-gpt-oss",
+    "args": [
+      "gt",
+      "do",
+      "Read task.md, implement the requested fix, and meet every regression and quality constraint in the repository.",
+      "--max-attempts",
+      "3"
+    ]
+  },
+  "fixtures": [
+    {
+      "id": "ledger-deadlock",
+      "source": "benchmarks/fixtures/go-ledger",
+      "require_failing_baseline": true,
+      "verifications": [
+        {
+          "name": "tests-race-and-quality-contract",
+          "args": ["go", "test", "-count=1", "-race", "./..."]
+        },
+        {
+          "name": "static-analysis",
+          "args": ["go", "vet", "./..."]
+        }
+      ]
+    },
+    {
+      "id": "cache-expiration",
+      "source": "benchmarks/fixtures/go-expiring-cache",
+      "require_failing_baseline": true,
+      "verifications": [
+        {
+          "name": "tests-race-and-quality-contract",
+          "args": ["go", "test", "-count=1", "-race", "./..."]
+        },
+        {
+          "name": "static-analysis",
+          "args": ["go", "vet", "./..."]
+        }
+      ]
+    },
+    {
+      "id": "safe-store",
+      "source": "benchmarks/fixtures/go-safe-store",
+      "require_failing_baseline": true,
+      "verifications": [
+        {
+          "name": "tests-race-and-quality-contract",
+          "args": ["go", "test", "-count=1", "-race", "./..."]
+        },
+        {
+          "name": "static-analysis",
+          "args": ["go", "vet", "./..."]
+        }
+      ]
+    }
+  ]
+}
diff --git a/benchmarks/suites/local-qwen3-coder-cache.json b/benchmarks/suites/local-qwen3-coder-cache.json
new file mode 100644
index 0000000..f84d261
--- /dev/null
+++ b/benchmarks/suites/local-qwen3-coder-cache.json
@@ -0,0 +1,39 @@
+{
+  "id": "go-cache-qwen3-coder-reviewed",
+  "output": "/tmp/gptcode-qwen-cache-reviewed",
+  "repetitions": 3,
+  "run_timeout_seconds": 600,
+  "setup": [
+    {
+      "name": "select-local-qwen3-coder-profile",
+      "args": ["gt", "profiles", "use", "local.evaluation"]
+    }
+  ],
+  "agent": {
+    "name": "gptcode-local-qwen3-coder",
+    "args": [
+      "gt",
+      "do",
+      "Read task.md, implement the requested fix, and meet every regression and quality constraint in the repository.",
+      "--max-attempts",
+      "3"
+    ]
+  },
+  "fixtures": [
+    {
+      "id": "cache-expiration",
+      "source": "benchmarks/fixtures/go-expiring-cache",
+      "require_failing_baseline": true,
+      "verifications": [
+        {
+          "name": "tests-race-and-quality-contract",
+          "args": ["go", "test", "-count=1", "-race", "./..."]
+        },
+        {
+          "name": "static-analysis",
+          "args": ["go", "vet", "./..."]
+        }
+      ]
+    }
+  ]
+}
diff --git a/benchmarks/suites/local-qwen3-coder.json b/benchmarks/suites/local-qwen3-coder.json
new file mode 100644
index 0000000..17a460d
--- /dev/null
+++ b/benchmarks/suites/local-qwen3-coder.json
@@ -0,0 +1,69 @@
+{
+  "id": "go-core-quality-qwen3-coder",
+  "output": "/tmp/gptcode-go-core-quality-qwen3-coder",
+  "repetitions": 3,
+  "run_timeout_seconds": 600,
+  "setup": [
+    {
+      "name": "select-local-qwen3-coder-profile",
+      "args": ["gt", "profiles", "use", "local.evaluation"]
+    }
+  ],
+  "agent": {
+    "name": "gptcode-local-qwen3-coder",
+    "args": [
+      "gt",
+      "do",
+      "Read task.md, implement the requested fix, and meet every regression and quality constraint in the repository.",
+      "--max-attempts",
+      "3"
+    ]
+  },
+  "fixtures": [
+    {
+      "id": "ledger-deadlock",
+      "source": "benchmarks/fixtures/go-ledger",
+      "require_failing_baseline": true,
+      "verifications": [
+        {
+          "name": "tests-race-and-quality-contract",
+          "args": ["go", "test", "-count=1", "-race", "./..."]
+        },
+        {
+          "name": "static-analysis",
+          "args": ["go", "vet", "./..."]
+        }
+      ]
+    },
+    {
+      "id": "cache-expiration",
+      "source": "benchmarks/fixtures/go-expiring-cache",
+      "require_failing_baseline": true,
+      "verifications": [
+        {
+          "name": "tests-race-and-quality-contract",
+          "args": ["go", "test", "-count=1", "-race", "./..."]
+        },
+        {
+          "name": "static-analysis",
+          "args": ["go", "vet", "./..."]
+        }
+      ]
+    },
+    {
+      "id": "safe-store",
+      "source": "benchmarks/fixtures/go-safe-store",
+      "require_failing_baseline": true,
+      "verifications": [
+        {
+          "name": "tests-race-and-quality-contract",
+          "args": ["go", "test", "-count=1", "-race", "./..."]
+        },
+        {
+          "name": "static-analysis",
+          "args": ["go", "vet", "./..."]
+        }
+      ]
+    }
+  ]
+}
diff --git a/internal/agents/editor.go b/internal/agents/editor.go
index 6d9d82b..f03d89e 100644
--- a/internal/agents/editor.go
+++ b/internal/agents/editor.go
@@ -103,7 +103,9 @@ WORKFLOW:
 1. For file reading: Call read_file to get current content
 2. For shell commands: Call run_command (e.g., "gh pr list", "go test", "npm run lint")
 3. For file modification: Call apply_patch for small changes, or write_file for new files/large rewrites
-4. **WHEN DONE**: Stop immediately. Do NOT call tools again. Return success message.
+4. Run the relevant repository verification after editing. If it fails, use the
+   output to repair the implementation before returning.
+5. **WHEN DONE**: Return a brief success message.
 
 CRITICAL RULES:
 - Use run_command for ANY shell operation (git, gh, tests, linters, etc)
@@ -113,7 +115,7 @@ CRITICAL RULES:
 - NEVER use placeholders like "[previous content]" or "[rest of file]"
 - NEVER create fake/placeholder files instead of using run_command
 - **IDEMPOTENCY**: Before modifying, check if change already exists. Don't apply same patch twice
-- **ONE CHANGE PER FILE**: After modifying a file, do NOT modify it again in same turn
+- A failed command is actionable feedback: repair the same file when necessary
 - **GO PACKAGE NAMES**: When editing Go files, NEVER change the package declaration unless explicitly asked. If main.go has "package main", ALL files in the same directory MUST use "package main". Do NOT infer package names from filenames (e.g., utils.go should NOT have "package utils" if it's in a package main directory)
 
 EXAMPLE 1 - Using run_command (for shell operations):
@@ -327,8 +329,10 @@ func (e *EditorAgent) Execute(ctx context.Context, history []llm.ChatMessage, st
 	// Tool call processing loop: handles multiple sequential tool calls within a single editor run.
 	// The outer retry logic (errors, validation failures) is controlled by Maestro's LoopDetector.
 	// This internal loop is for processing a chain of tool calls (discovery → read → write).
-	// Set to 10 to allow complex tasks: 3-4 discovery calls + 2-3 reads + 2-3 writes
-	maxToolChainDepth := 10
+	// Local models commonly need a longer inspect → edit → verify → repair chain
+	// than hosted models. Keep the outer conductor responsible for retries, but
+	// do not truncate a productive in-turn tool chain before validation.
+	maxToolChainDepth := 20
 	for iteration := 0; iteration < maxToolChainDepth; iteration++ {
 		llmStart := time.Now()
 		resp, err := e.provider.Chat(ctx, llm.ChatRequest{
@@ -461,9 +465,6 @@ func (e *EditorAgent) Execute(ctx context.Context, history []llm.ChatMessage, st
 						fmt.Fprintf(os.Stderr, "[EDITOR] Executed %s: %s\n", tc.Name, result.Result[:min(50, len(result.Result))])
 					}
 				}
-				if e.allExpectedFilesModified(modifiedFiles) {
-					return "All planned files changed; awaiting deterministic validation", modifiedFiles, nil
-				}
 				continue
 			}
 			if editRequested(messages) && len(modifiedFiles) == 0 {
@@ -565,9 +566,6 @@ func (e *EditorAgent) Execute(ctx context.Context, history []llm.ChatMessage, st
 				fmt.Fprintf(os.Stderr, "[EDITOR] Executed %s: %s\n", tc.Name, result.Result[:min(50, len(result.Result))])
 			}
 		}
-		if e.allExpectedFilesModified(modifiedFiles) {
-			return "All planned files changed; awaiting deterministic validation", modifiedFiles, nil
-		}
 	}
 
 	if editRequested(messages) && len(modifiedFiles) == 0 {
@@ -577,25 +575,6 @@ func (e *EditorAgent) Execute(ctx context.Context, history []llm.ChatMessage, st
 	return "Editor reached max iterations", modifiedFiles, nil
 }
 
-func (e *EditorAgent) allExpectedFilesModified(modifiedFiles []string) bool {
-	if len(e.allowedFiles) == 0 {
-		return false
-	}
-	for _, expected := range e.allowedFiles {
-		found := false
-		for _, modified := range modifiedFiles {
-			if modified == expected || strings.HasSuffix(modified, expected) || strings.HasSuffix(expected, modified) {
-				found = true
-				break
-			}
-		}
-		if !found {
-			return false
-		}
-	}
-	return true
-}
-
 func min(a, b int) int {
 	if a < b {
 		return a
diff --git a/internal/agents/editor_test.go b/internal/agents/editor_test.go
index 634cbca..9cc12e8 100644
--- a/internal/agents/editor_test.go
+++ b/internal/agents/editor_test.go
@@ -2,6 +2,7 @@ package agents
 
 import (
 	"context"
+	"fmt"
 	"os"
 	"path/filepath"
 	"strings"
@@ -525,16 +526,19 @@ func TestEditor_EditTask_ModifiesEveryPlannedFileBeforeCompleting(t *testing.T)
 	}
 }
 
-func TestEditor_EditTask_StopsWhenEveryExpectedFileWasModified(t *testing.T) {
+func TestEditor_EditTask_WaitsForModelCompletionAfterExpectedFilesChange(t *testing.T) {
 	tmpDir := t.TempDir()
 	mock := &mockProvider{
-		responses: []llm.ChatResponse{{
-			ToolCalls: []llm.ChatToolCall{{
-				ID:        "1",
-				Name:      "write_file",
-				Arguments: `{"path":"counter.go","content":"package counter"}`,
-			}},
-		}},
+		responses: []llm.ChatResponse{
+			{
+				ToolCalls: []llm.ChatToolCall{{
+					ID:        "1",
+					Name:      "write_file",
+					Arguments: `{"path":"counter.go","content":"package counter"}`,
+				}},
+			},
+			{Text: "Implemented counter.go; ready for deterministic validation."},
+		},
 	}
 
 	editor := NewEditor(mock, tmpDir, "test-model")
@@ -547,14 +551,98 @@ func TestEditor_EditTask_StopsWhenEveryExpectedFileWasModified(t *testing.T) {
 	if err != nil {
 		t.Fatalf("expected edit to complete: %v", err)
 	}
-	if result != "All planned files changed; awaiting deterministic validation" {
+	if result != "Implemented counter.go; ready for deterministic validation." {
 		t.Fatalf("unexpected completion: %q", result)
 	}
 	if len(modifiedFiles) != 1 || modifiedFiles[0] != "counter.go" {
 		t.Fatalf("unexpected modified files: %v", modifiedFiles)
 	}
-	if mock.callCount != 1 {
-		t.Fatalf("expected no extra model completion call, got %d", mock.callCount)
+	if mock.callCount != 2 {
+		t.Fatalf("expected an explicit completion after the write, got %d calls", mock.callCount)
+	}
+}
+
+func TestEditor_EditTask_CanRepairSameFileAfterCommandFailure(t *testing.T) {
+	tmpDir := t.TempDir()
+	mock := &mockProvider{
+		responses: []llm.ChatResponse{
+			{ToolCalls: []llm.ChatToolCall{{
+				ID:        "1",
+				Name:      "write_file",
+				Arguments: `{"path":"counter.go","content":"package counter\n\nvar Value = broken"}`,
+			}}},
+			{ToolCalls: []llm.ChatToolCall{{
+				ID:        "2",
+				Name:      "run_command",
+				Arguments: `{"command":"test \"$(tail -n 1 counter.go)\" = \"var Value = 1\""}`,
+			}}},
+			{ToolCalls: []llm.ChatToolCall{{
+				ID:        "3",
+				Name:      "apply_patch",
+				Arguments: `{"path":"counter.go","search":"var Value = broken","replace":"var Value = 1"}`,
+			}}},
+			{Text: "Verification failure repaired."},
+		},
+	}
+
+	editor := NewEditor(mock, tmpDir, "test-model")
+	editor.SetExpectedFiles([]string{"counter.go"})
+	result, modifiedFiles, err := editor.Execute(context.Background(), []llm.ChatMessage{{
+		Role:    "user",
+		Content: "Fix counter.go and verify the result.",
+	}}, nil)
+
+	if err != nil {
+		t.Fatalf("expected in-turn repair to complete: %v", err)
+	}
+	if result != "Verification failure repaired." {
+		t.Fatalf("unexpected completion: %q", result)
+	}
+	content, err := os.ReadFile(filepath.Join(tmpDir, "counter.go"))
+	if err != nil {
+		t.Fatal(err)
+	}
+	if !strings.Contains(string(content), "var Value = 1") {
+		t.Fatalf("same-file repair was not applied: %s", content)
+	}
+	if len(modifiedFiles) != 2 {
+		t.Fatalf("expected both writes to be recorded, got %v", modifiedFiles)
+	}
+}
+
+func TestEditor_EditTask_AllowsGroundedToolChainsBeyondTenCalls(t *testing.T) {
+	tmpDir := t.TempDir()
+	if err := os.WriteFile(filepath.Join(tmpDir, "counter.go"), []byte("package counter\n"), 0o644); err != nil {
+		t.Fatal(err)
+	}
+
+	responses := make([]llm.ChatResponse, 0, 14)
+	for i := 0; i < 11; i++ {
+		responses = append(responses, llm.ChatResponse{ToolCalls: []llm.ChatToolCall{{
+			ID:        fmt.Sprintf("read-%d", i),
+			Name:      "read_file",
+			Arguments: `{"path":"counter.go"}`,
+		}}})
+	}
+	responses = append(responses,
+		llm.ChatResponse{ToolCalls: []llm.ChatToolCall{{
+			ID:        "write",
+			Name:      "apply_patch",
+			Arguments: `{"path":"counter.go","search":"package counter","replace":"package counter\n\nvar Value = 1"}`,
+		}}},
+		llm.ChatResponse{Text: "Grounded implementation complete."},
+	)
+
+	editor := NewEditor(&mockProvider{responses: responses}, tmpDir, "test-model")
+	result, modifiedFiles, err := editor.Execute(context.Background(), []llm.ChatMessage{{
+		Role:    "user",
+		Content: "Fix counter.go after inspecting the repository evidence.",
+	}}, nil)
+	if err != nil {
+		t.Fatalf("expected a long grounded tool chain to complete: %v", err)
+	}
+	if result != "Grounded implementation complete." || len(modifiedFiles) != 1 {
+		t.Fatalf("unexpected result %q with files %v", result, modifiedFiles)
 	}
 }
 
diff --git a/internal/agents/query.go b/internal/agents/query.go
index 5c1e2ca..7fe3275 100644
--- a/internal/agents/query.go
+++ b/internal/agents/query.go
@@ -4,6 +4,7 @@ import (
 	"context"
 	"fmt"
 	"os"
+	"strings"
 
 	"github.com/jadercorrea/gptcode/internal/llm"
 	"github.com/jadercorrea/gptcode/internal/tools"
@@ -135,6 +136,14 @@ func (q *QueryAgent) Execute(ctx context.Context, history []llm.ChatMessage, sta
 		}
 
 		if len(resp.ToolCalls) == 0 {
+			if strings.TrimSpace(resp.Text) == "" {
+				messages = append(messages, llm.ChatMessage{
+					Role: "user",
+					Content: "The previous answer was empty. Answer the original question using the supplied " +
+						"repository evidence. Include concrete file paths and verification commands.",
+				})
+				continue
+			}
 			return resp.Text, nil
 		}
 
@@ -193,6 +202,9 @@ func (q *QueryAgent) Execute(ctx context.Context, history []llm.ChatMessage, sta
 	if err != nil {
 		return "", err
 	}
+	if strings.TrimSpace(finalResp.Text) == "" {
+		return "", fmt.Errorf("query returned an empty answer after %d attempts", maxIterations+1)
+	}
 
 	return finalResp.Text, nil
 }
diff --git a/internal/agents/query_test.go b/internal/agents/query_test.go
new file mode 100644
index 0000000..feae82b
--- /dev/null
+++ b/internal/agents/query_test.go
@@ -0,0 +1,30 @@
+package agents
+
+import (
+	"context"
+	"testing"
+
+	"github.com/jadercorrea/gptcode/internal/llm"
+)
+
+func TestQueryRetriesAnEmptyAnswer(t *testing.T) {
+	provider := &mockProvider{responses: []llm.ChatResponse{
+		{Text: ""},
+		{Text: "The cache uses an RWMutex and verifies behavior with go test -race ./..."},
+	}}
+	query := NewQuery(provider, t.TempDir(), "test-model")
+
+	result, err := query.Execute(context.Background(), []llm.ChatMessage{{
+		Role:    "user",
+		Content: "Explain cache concurrency.",
+	}}, nil)
+	if err != nil {
+		t.Fatalf("expected empty answer recovery: %v", err)
+	}
+	if result == "" {
+		t.Fatal("expected a grounded non-empty answer")
+	}
+	if provider.callCount != 2 {
+		t.Fatalf("expected one retry after the empty answer, got %d calls", provider.callCount)
+	}
+}
diff --git a/internal/autonomous/analyzer.go b/internal/autonomous/analyzer.go
index ec825e6..fb46341 100644
--- a/internal/autonomous/analyzer.go
+++ b/internal/autonomous/analyzer.go
@@ -141,17 +141,51 @@ type TaskAnalysis struct {
 	Movements     []Movement `json:"movements,omitempty"`
 }
 
+// FileReferences accepts the compact string format requested by the prompt
+// and the structured path objects commonly emitted by local models.
+type FileReferences []string
+
+func (references *FileReferences) UnmarshalJSON(data []byte) error {
+	var values []json.RawMessage
+	if err := json.Unmarshal(data, &values); err != nil {
+		return err
+	}
+	parsed := make(FileReferences, 0, len(values))
+	for index, value := range values {
+		var path string
+		if err := json.Unmarshal(value, &path); err == nil {
+			if path == "" {
+				return fmt.Errorf("file reference %d is empty", index)
+			}
+			parsed = append(parsed, path)
+			continue
+		}
+		var structured struct {
+			Path string `json:"path"`
+		}
+		if err := json.Unmarshal(value, &structured); err != nil {
+			return fmt.Errorf("decoding file reference %d: %w", index, err)
+		}
+		if structured.Path == "" {
+			return fmt.Errorf("file reference %d is missing path", index)
+		}
+		parsed = append(parsed, structured.Path)
+	}
+	*references = parsed
+	return nil
+}
+
 // Movement represents a single phase in a complex task
 type Movement struct {
-	ID              string   `json:"id"`
-	Name            string   `json:"name"`
-	Description     string   `json:"description"`
-	Goal            string   `json:"goal"`
-	Dependencies    []string `json:"dependencies"`
-	RequiredFiles   []string `json:"required_files"`
-	OutputFiles     []string `json:"output_files"`
-	SuccessCriteria []string `json:"success_criteria"`
-	Status          string   `json:"status"` // "pending", "executing", "completed", "failed"
+	ID              string         `json:"id"`
+	Name            string         `json:"name"`
+	Description     string         `json:"description"`
+	Goal            string         `json:"goal"`
+	Dependencies    []string       `json:"dependencies"`
+	RequiredFiles   FileReferences `json:"required_files"`
+	OutputFiles     FileReferences `json:"output_files"`
+	SuccessCriteria []string       `json:"success_criteria"`
+	Status          string         `json:"status"` // "pending", "executing", "completed", "failed"
 }
 
 // TaskAnalyzer analyzes tasks and decomposes them into movements if complex
diff --git a/internal/autonomous/movement_test.go b/internal/autonomous/movement_test.go
new file mode 100644
index 0000000..d8780ba
--- /dev/null
+++ b/internal/autonomous/movement_test.go
@@ -0,0 +1,38 @@
+package autonomous
+
+import (
+	"encoding/json"
+	"reflect"
+	"testing"
+)
+
+func TestMovementAcceptsStringAndStructuredFileReferences(t *testing.T) {
+	var movement Movement
+	err := json.Unmarshal([]byte(`{
+		"id": "movement-1",
+		"required_files": [
+			"task.md",
+			{"path": "cache.go", "content_type": "read"}
+		],
+		"output_files": [
+			{"path": "cache.go"}
+		]
+	}`), &movement)
+	if err != nil {
+		t.Fatalf("json.Unmarshal() error = %v", err)
+	}
+	if want := (FileReferences{"task.md", "cache.go"}); !reflect.DeepEqual(movement.RequiredFiles, want) {
+		t.Fatalf("RequiredFiles = %v, want %v", movement.RequiredFiles, want)
+	}
+	if want := (FileReferences{"cache.go"}); !reflect.DeepEqual(movement.OutputFiles, want) {
+		t.Fatalf("OutputFiles = %v, want %v", movement.OutputFiles, want)
+	}
+}
+
+func TestMovementRejectsStructuredFileWithoutPath(t *testing.T) {
+	var movement Movement
+	err := json.Unmarshal([]byte(`{"required_files":[{"content_type":"read"}]}`), &movement)
+	if err == nil {
+		t.Fatal("json.Unmarshal() error = nil, want missing path rejection")
+	}
+}
diff --git a/internal/config/model_selector.go b/internal/config/model_selector.go
index f065996..7dfda79 100644
--- a/internal/config/model_selector.go
+++ b/internal/config/model_selector.go
@@ -381,6 +381,20 @@ func (ms *ModelSelector) SelectModel(action ActionType, language string, complex
 	mode := ms.setup.Defaults.Mode
 	defaultBackend := ms.setup.Defaults.Backend
 
+	// An explicit model in the active backend/profile is the user's routing
+	// decision. Approved models are fallbacks and must not silently move a
+	// local execution to a cloud backend.
+	if backendCfg, ok := ms.setup.Backend[defaultBackend]; ok {
+		configuredModel := explicitlyConfiguredModelForAction(backendCfg, ms.setup.Defaults.Profile, action)
+		if configuredModel != "" {
+			if os.Getenv("GPTCODE_DEBUG") == "1" {
+				fmt.Fprintf(os.Stderr, "[MODEL_SELECTOR] Using configured model for action=%s: %s/%s\n",
+					action, defaultBackend, configuredModel)
+			}
+			return defaultBackend, configuredModel, nil
+		}
+	}
+
 	// First, try approved models for this action
 	approvedModels := ms.setup.GetApprovedModelsForAction(string(action))
 	if len(approvedModels) > 0 {
@@ -389,6 +403,9 @@ func (ms *ModelSelector) SelectModel(action ActionType, language string, complex
 		}
 		for _, approved := range approvedModels {
 			backend, model, err := ms.trySelectApprovedModel(approved.Model, action, language, complexity)
+			if err == nil && !modeAllowsBackend(mode, backend, ms.setup) {
+				err = fmt.Errorf("backend %q is not allowed in %s mode", backend, mode)
+			}
 			if err == nil {
 				if os.Getenv("GPTCODE_DEBUG") == "1" {
 					fmt.Fprintf(os.Stderr, "[MODEL_SELECTOR] Approved model selected: %s/%s\n", backend, model)
@@ -408,17 +425,6 @@ func (ms *ModelSelector) SelectModel(action ActionType, language string, complex
 		return "", "", fmt.Errorf("all approved models failed for action=%s (check setup.yaml and models_catalog.json)", action)
 	}
 
-	if backendCfg, ok := ms.setup.Backend[defaultBackend]; ok {
-		configuredModel := configuredModelForAction(backendCfg, ms.setup.Defaults.Profile, action)
-		if configuredModel != "" {
-			if os.Getenv("GPTCODE_DEBUG") == "1" {
-				fmt.Fprintf(os.Stderr, "[MODEL_SELECTOR] Using configured model for action=%s: %s/%s\n",
-					action, defaultBackend, configuredModel)
-			}
-			return defaultBackend, configuredModel, nil
-		}
-	}
-
 	type scoredModel struct {
 		backend string
 		model   string
@@ -504,6 +510,38 @@ func (ms *ModelSelector) SelectModel(action ActionType, language string, complex
 	return best.backend, best.model, nil
 }
 
+func modeAllowsBackend(mode, backendName string, setup *Setup) bool {
+	backend, configured := setup.Backend[backendName]
+	isLocal := backendName == "ollama" || (configured && backend.Type == "ollama")
+	switch mode {
+	case "local":
+		return isLocal
+	case "cloud":
+		return !isLocal
+	default:
+		return true
+	}
+}
+
+func explicitlyConfiguredModelForAction(backend BackendConfig, profile string, action ActionType) string {
+	models := backend.AgentModels
+	if profile != "" && profile != "default" {
+		if configuredProfile, ok := backend.Profiles[profile]; ok {
+			models = configuredProfile.AgentModels
+		}
+	}
+	switch action {
+	case ActionEdit:
+		return models.Editor
+	case ActionResearch:
+		return models.Research
+	case ActionPlan, ActionReview, ActionRoute:
+		return models.Query
+	default:
+		return ""
+	}
+}
+
 func configuredModelForAction(backend BackendConfig, profile string, action ActionType) string {
 	switch action {
 	case ActionEdit:
diff --git a/internal/config/model_selector_test.go b/internal/config/model_selector_test.go
index 6cb9a80..f7f0e6b 100644
--- a/internal/config/model_selector_test.go
+++ b/internal/config/model_selector_test.go
@@ -55,6 +55,70 @@ func TestSelectModelPrefersConfiguredEditor(t *testing.T) {
 	}
 }
 
+func TestSelectModelPrefersExplicitLocalProfileOverApprovedCloudModel(t *testing.T) {
+	setup := &Setup{
+		Backend: map[string]BackendConfig{
+			"local": {
+				Type: "ollama",
+				Profiles: map[string]ProfileConfig{
+					"evaluation": {
+						AgentModels: AgentModels{
+							Query: "qwen3-coder:latest",
+						},
+					},
+				},
+			},
+			"openrouter": {
+				Type: "openai",
+			},
+		},
+		ApprovedModels: []ApprovedModel{
+			{Model: "openai/o3-mini", ForActions: []string{string(ActionPlan)}},
+		},
+	}
+	setup.Defaults.Backend = "local"
+	setup.Defaults.Profile = "evaluation"
+	setup.Defaults.Mode = "local"
+
+	selector := &ModelSelector{setup: setup}
+	backend, model, err := selector.SelectModel(ActionPlan, "go", "complex")
+	if err != nil {
+		t.Fatal(err)
+	}
+	if backend != "local" || model != "qwen3-coder:latest" {
+		t.Fatalf("selected %s/%s, want explicit local profile", backend, model)
+	}
+}
+
+func TestSelectModelNeverRoutesLocalModeToApprovedCloudBackend(t *testing.T) {
+	setup := &Setup{
+		Backend: map[string]BackendConfig{
+			"local": {
+				Type: "ollama",
+			},
+			"openrouter": {
+				Type: "openai",
+			},
+		},
+		ApprovedModels: []ApprovedModel{
+			{Model: "google/gemini-2.5-pro", ForActions: []string{string(ActionPlan)}},
+		},
+	}
+	setup.Defaults.Backend = "local"
+	setup.Defaults.Mode = "local"
+
+	selector := &ModelSelector{
+		setup: setup,
+		catalog: map[string][]ModelInfo{
+			"openrouter": {{ID: "google/gemini-2.5-pro"}},
+		},
+	}
+	backend, model, err := selector.SelectModel(ActionPlan, "go", "complex")
+	if err == nil {
+		t.Fatalf("SelectModel() = %s/%s, want local-mode cloud rejection", backend, model)
+	}
+}
+
 func TestApprovedOpenRouterModelUsesConfiguredBackend(t *testing.T) {
 	setup := &Setup{
 		Backend: map[string]BackendConfig{
diff --git a/internal/evidence/bundle.go b/internal/evidence/bundle.go
new file mode 100644
index 0000000..dd3cd75
--- /dev/null
+++ b/internal/evidence/bundle.go
@@ -0,0 +1,511 @@
+package evidence
+
+import (
+	"archive/tar"
+	"bufio"
+	"context"
+	"crypto/sha256"
+	"encoding/hex"
+	"encoding/json"
+	"errors"
+	"fmt"
+	"io"
+	"os"
+	"os/exec"
+	"path/filepath"
+	"sort"
+	"strings"
+	"sync"
+	"time"
+)
+
+const EvidenceSchemaVersion = "gptcode.evidence/v1"
+
+type Command struct {
+	Name string   `json:"name"`
+	Args []string `json:"args"`
+}
+
+type Experiment struct {
+	ID            string        `json:"id"`
+	Repository    string        `json:"repository"`
+	Output        string        `json:"output"`
+	Agent         Command       `json:"agent"`
+	Verifications []Command     `json:"verifications"`
+	AgentTimeout  time.Duration `json:"-"`
+	Progress      io.Writer     `json:"-"`
+}
+
+type Snapshot struct {
+	FileCount int    `json:"file_count"`
+	SHA256    string `json:"sha256"`
+}
+
+type Manifest struct {
+	SchemaVersion   string    `json:"schema_version"`
+	ExperimentID    string    `json:"experiment_id"`
+	BaseCommit      string    `json:"base_commit"`
+	StartedAt       time.Time `json:"started_at"`
+	CompletedAt     time.Time `json:"completed_at"`
+	InitialSnapshot Snapshot  `json:"initial_snapshot"`
+	FinalSnapshot   Snapshot  `json:"final_snapshot"`
+}
+
+type CommandResult struct {
+	Name      string        `json:"name"`
+	Args      []string      `json:"args"`
+	StartedAt time.Time     `json:"started_at"`
+	Duration  time.Duration `json:"duration"`
+	ExitCode  int           `json:"exit_code"`
+	Stdout    string        `json:"stdout"`
+	Stderr    string        `json:"stderr"`
+}
+
+type VerificationReport struct {
+	Passed   bool            `json:"passed"`
+	Commands []CommandResult `json:"commands"`
+}
+
+type ExperimentResult struct {
+	Passed   bool
+	TimedOut bool
+}
+
+type bundleEvent struct {
+	Type string    `json:"type"`
+	At   time.Time `json:"at"`
+}
+
+// RunExperiment executes one agent command and its deterministic checks in a
+// clean Git fixture, preserving enough state to inspect and replay the run.
+func RunExperiment(ctx context.Context, experiment Experiment) (ExperimentResult, error) {
+	if err := validateExperiment(experiment); err != nil {
+		return ExperimentResult{}, err
+	}
+
+	baseCommit, err := gitOutput(ctx, experiment.Repository, "rev-parse", "HEAD")
+	if err != nil {
+		return ExperimentResult{}, fmt.Errorf("reading base commit: %w", err)
+	}
+	status, err := gitOutput(ctx, experiment.Repository, "status", "--porcelain=v1", "--untracked-files=all")
+	if err != nil {
+		return ExperimentResult{}, fmt.Errorf("checking repository state: %w", err)
+	}
+	if status != "" {
+		return ExperimentResult{}, errors.New("repository must be clean before an experiment")
+	}
+	if _, err := os.Stat(experiment.Output); err == nil {
+		return ExperimentResult{}, errors.New("evidence directory already exists")
+	} else if !errors.Is(err, os.ErrNotExist) {
+		return ExperimentResult{}, fmt.Errorf("checking evidence directory: %w", err)
+	}
+	if err := os.Mkdir(experiment.Output, 0o700); err != nil {
+		return ExperimentResult{}, fmt.Errorf("creating evidence directory: %w", err)
+	}
+
+	started := time.Now().UTC()
+	events, err := os.Create(filepath.Join(experiment.Output, "events.jsonl"))
+	if err != nil {
+		return ExperimentResult{}, fmt.Errorf("creating event log: %w", err)
+	}
+	defer events.Close()
+	eventEncoder := json.NewEncoder(events)
+
+	initial, err := writeSnapshot(experiment.Repository, filepath.Join(experiment.Output, "initial.tar"))
+	if err != nil {
+		return ExperimentResult{}, fmt.Errorf("capturing initial snapshot: %w", err)
+	}
+	if err := writeGitDiff(ctx, experiment.Repository, filepath.Join(experiment.Output, "initial.patch")); err != nil {
+		return ExperimentResult{}, err
+	}
+	if err := eventEncoder.Encode(bundleEvent{Type: "agent_started", At: time.Now().UTC()}); err != nil {
+		return ExperimentResult{}, fmt.Errorf("recording agent start: %w", err)
+	}
+
+	agentContext := ctx
+	cancelAgent := func() {}
+	if experiment.AgentTimeout > 0 {
+		agentContext, cancelAgent = context.WithTimeout(ctx, experiment.AgentTimeout)
+	}
+	var progress []io.Writer
+	if experiment.Progress != nil {
+		progress = append(progress, experiment.Progress)
+	}
+	agentResult := runCommand(agentContext, experiment.Repository, experiment.Agent, progress...)
+	timedOut := errors.Is(agentContext.Err(), context.DeadlineExceeded)
+	cancelAgent()
+	if err := appendJSONLine(filepath.Join(experiment.Output, "commands.jsonl"), agentResult); err != nil {
+		return ExperimentResult{}, err
+	}
+	if err := eventEncoder.Encode(bundleEvent{Type: "agent_completed", At: time.Now().UTC()}); err != nil {
+		return ExperimentResult{}, fmt.Errorf("recording agent completion: %w", err)
+	}
+	if err := writeGitDiff(ctx, experiment.Repository, filepath.Join(experiment.Output, "agent.patch")); err != nil {
+		return ExperimentResult{}, err
+	}
+
+	verification := VerificationReport{Passed: agentResult.ExitCode == 0}
+	for _, check := range experiment.Verifications {
+		result := runCommand(ctx, experiment.Repository, check)
+		verification.Commands = append(verification.Commands, result)
+		if result.ExitCode != 0 {
+			verification.Passed = false
+		}
+		if err := appendJSONLine(filepath.Join(experiment.Output, "commands.jsonl"), result); err != nil {
+			return ExperimentResult{}, err
+		}
+	}
+	if err := writeJSON(filepath.Join(experiment.Output, "verification.json"), verification); err != nil {
+		return ExperimentResult{}, err
+	}
+	if err := eventEncoder.Encode(bundleEvent{Type: "verification_completed", At: time.Now().UTC()}); err != nil {
+		return ExperimentResult{}, fmt.Errorf("recording verification completion: %w", err)
+	}
+
+	finalSnapshot, err := writeSnapshot(experiment.Repository, filepath.Join(experiment.Output, "final.tar"))
+	if err != nil {
+		return ExperimentResult{}, fmt.Errorf("capturing final snapshot: %w", err)
+	}
+	if err := writeGitDiff(ctx, experiment.Repository, filepath.Join(experiment.Output, "final.patch")); err != nil {
+		return ExperimentResult{}, err
+	}
+
+	manifest := Manifest{
+		SchemaVersion:   EvidenceSchemaVersion,
+		ExperimentID:    experiment.ID,
+		BaseCommit:      strings.TrimSpace(baseCommit),
+		StartedAt:       started,
+		CompletedAt:     time.Now().UTC(),
+		InitialSnapshot: initial,
+		FinalSnapshot:   finalSnapshot,
+	}
+	if err := writeJSON(filepath.Join(experiment.Output, "manifest.json"), manifest); err != nil {
+		return ExperimentResult{}, err
+	}
+	if err := writeReport(filepath.Join(experiment.Output, "report.md"), manifest, agentResult, verification); err != nil {
+		return ExperimentResult{}, err
+	}
+
+	return ExperimentResult{Passed: verification.Passed, TimedOut: timedOut}, nil
+}
+
+func validateExperiment(experiment Experiment) error {
+	if experiment.ID == "" {
+		return errors.New("experiment ID is required")
+	}
+	if experiment.Repository == "" || experiment.Output == "" {
+		return errors.New("repository and output paths are required")
+	}
+	if len(experiment.Agent.Args) == 0 || experiment.Agent.Name == "" {
+		return errors.New("agent name and executable are required")
+	}
+	if len(experiment.Verifications) == 0 {
+		return errors.New("at least one deterministic verification is required")
+	}
+	repository, err := filepath.Abs(experiment.Repository)
+	if err != nil {
+		return fmt.Errorf("resolving repository: %w", err)
+	}
+	output, err := filepath.Abs(experiment.Output)
+	if err != nil {
+		return fmt.Errorf("resolving output: %w", err)
+	}
+	relative, err := filepath.Rel(repository, output)
+	if err != nil {
+		return fmt.Errorf("comparing repository and output: %w", err)
+	}
+	if relative != ".." && !strings.HasPrefix(relative, ".."+string(filepath.Separator)) {
+		return errors.New("evidence output must be outside the evaluated repository")
+	}
+	for _, command := range experiment.Verifications {
+		if command.Name == "" || len(command.Args) == 0 {
+			return errors.New("verification name and executable are required")
+		}
+	}
+	return nil
+}
+
+func runCommand(ctx context.Context, directory string, command Command, mirrors ...io.Writer) CommandResult {
+	started := time.Now().UTC()
+	process := exec.CommandContext(ctx, command.Args[0], command.Args[1:]...)
+	process.Dir = directory
+	var stdout, stderr strings.Builder
+	stdoutWriters := []io.Writer{&stdout}
+	stderrWriters := []io.Writer{&stderr}
+	if len(mirrors) > 0 {
+		progress := &synchronizedWriter{writer: io.MultiWriter(mirrors...)}
+		stdoutWriters = append(stdoutWriters, progress)
+		stderrWriters = append(stderrWriters, progress)
+	}
+	process.Stdout = io.MultiWriter(stdoutWriters...)
+	process.Stderr = io.MultiWriter(stderrWriters...)
+	err := process.Run()
+
+	exitCode := 0
+	if err != nil {
+		exitCode = -1
+		var exitError *exec.ExitError
+		if errors.As(err, &exitError) {
+			exitCode = exitError.ExitCode()
+		}
+	}
+	return CommandResult{
+		Name:      command.Name,
+		Args:      append([]string(nil), command.Args...),
+		StartedAt: started,
+		Duration:  time.Since(started),
+		ExitCode:  exitCode,
+		Stdout:    stdout.String(),
+		Stderr:    stderr.String(),
+	}
+}
+
+type synchronizedWriter struct {
+	mu     sync.Mutex
+	writer io.Writer
+}
+
+func (w *synchronizedWriter) Write(content []byte) (int, error) {
+	w.mu.Lock()
+	defer w.mu.Unlock()
+	return w.writer.Write(content)
+}
+
+func writeSnapshot(root, destination string) (Snapshot, error) {
+	paths, err := snapshotPaths(root)
+	if err != nil {
+		return Snapshot{}, err
+	}
+	file, err := os.OpenFile(destination, os.O_CREATE|os.O_TRUNC|os.O_WRONLY, 0o600)
+	if err != nil {
+		return Snapshot{}, err
+	}
+	hash := sha256.New()
+	writer := tar.NewWriter(io.MultiWriter(file, hash))
+	for _, relative := range paths {
+		path := filepath.Join(root, relative)
+		info, err := os.Lstat(path)
+		if err != nil {
+			writer.Close()
+			file.Close()
+			return Snapshot{}, err
+		}
+		header, err := tar.FileInfoHeader(info, "")
+		if err != nil {
+			writer.Close()
+			file.Close()
+			return Snapshot{}, err
+		}
+		header.Name = filepath.ToSlash(relative)
+		header.ModTime = time.Unix(0, 0)
+		header.AccessTime = time.Time{}
+		header.ChangeTime = time.Time{}
+		header.Uid, header.Gid = 0, 0
+		header.Uname, header.Gname = "", ""
+		if err := writer.WriteHeader(header); err != nil {
+			writer.Close()
+			file.Close()
+			return Snapshot{}, err
+		}
+		if info.Mode().IsRegular() {
+			source, err := os.Open(path)
+			if err != nil {
+				writer.Close()
+				file.Close()
+				return Snapshot{}, err
+			}
+			_, copyErr := io.Copy(writer, source)
+			closeErr := source.Close()
+			if copyErr != nil {
+				writer.Close()
+				file.Close()
+				return Snapshot{}, copyErr
+			}
+			if closeErr != nil {
+				writer.Close()
+				file.Close()
+				return Snapshot{}, closeErr
+			}
+		}
+	}
+	if err := writer.Close(); err != nil {
+		file.Close()
+		return Snapshot{}, err
+	}
+	if err := file.Close(); err != nil {
+		return Snapshot{}, err
+	}
+	return Snapshot{FileCount: len(paths), SHA256: hex.EncodeToString(hash.Sum(nil))}, nil
+}
+
+func snapshotPaths(root string) ([]string, error) {
+	var paths []string
+	err := filepath.WalkDir(root, func(path string, entry os.DirEntry, walkErr error) error {
+		if walkErr != nil {
+			return walkErr
+		}
+		relative, err := filepath.Rel(root, path)
+		if err != nil {
+			return err
+		}
+		if relative == "." {
+			return nil
+		}
+		if relative == ".git" {
+			return filepath.SkipDir
+		}
+		info, err := entry.Info()
+		if err != nil {
+			return err
+		}
+		if !info.Mode().IsRegular() && !info.IsDir() {
+			return fmt.Errorf("unsupported snapshot file type at %q", relative)
+		}
+		paths = append(paths, relative)
+		return nil
+	})
+	sort.Strings(paths)
+	return paths, err
+}
+
+// RestoreSnapshot safely restores a bundle snapshot into an empty directory.
+func RestoreSnapshot(snapshotPath, destination string) error {
+	file, err := os.Open(snapshotPath)
+	if err != nil {
+		return err
+	}
+	defer file.Close()
+	reader := tar.NewReader(bufio.NewReader(file))
+	for {
+		header, err := reader.Next()
+		if errors.Is(err, io.EOF) {
+			return nil
+		}
+		if err != nil {
+			return err
+		}
+		path, err := safePath(destination, filepath.FromSlash(header.Name))
+		if err != nil {
+			return fmt.Errorf("unsafe snapshot entry: %w", err)
+		}
+		switch header.Typeflag {
+		case tar.TypeDir:
+			if err := os.MkdirAll(path, header.FileInfo().Mode().Perm()); err != nil {
+				return err
+			}
+		case tar.TypeReg:
+			if err := os.MkdirAll(filepath.Dir(path), 0o700); err != nil {
+				return err
+			}
+			output, err := os.OpenFile(path, os.O_CREATE|os.O_TRUNC|os.O_WRONLY, header.FileInfo().Mode().Perm())
+			if err != nil {
+				return err
+			}
+			_, copyErr := io.Copy(output, reader)
+			closeErr := output.Close()
+			if copyErr != nil {
+				return copyErr
+			}
+			if closeErr != nil {
+				return closeErr
+			}
+		default:
+			return fmt.Errorf("unsupported snapshot entry type %d", header.Typeflag)
+		}
+	}
+}
+
+func gitOutput(ctx context.Context, root string, args ...string) (string, error) {
+	command := exec.CommandContext(ctx, "git", args...)
+	command.Dir = root
+	command.Env = isolatedGitEnvironment()
+	output, err := command.CombinedOutput()
+	if err != nil {
+		return "", fmt.Errorf("git %s: %w: %s", strings.Join(args, " "), err, output)
+	}
+	return strings.TrimSpace(string(output)), nil
+}
+
+func isolatedGitEnvironment() []string {
+	blocked := map[string]struct{}{
+		"GIT_ALTERNATE_OBJECT_DIRECTORIES": {},
+		"GIT_COMMON_DIR":                   {},
+		"GIT_DIR":                          {},
+		"GIT_INDEX_FILE":                   {},
+		"GIT_OBJECT_DIRECTORY":             {},
+		"GIT_PREFIX":                       {},
+		"GIT_WORK_TREE":                    {},
+	}
+	environment := make([]string, 0, len(os.Environ()))
+	for _, variable := range os.Environ() {
+		name, _, _ := strings.Cut(variable, "=")
+		if _, found := blocked[name]; !found {
+			environment = append(environment, variable)
+		}
+	}
+	return environment
+}
+
+func writeGitDiff(ctx context.Context, root, destination string) error {
+	diff, err := gitOutput(ctx, root, "diff", "--binary", "--no-ext-diff", "HEAD")
+	if err != nil {
+		return fmt.Errorf("capturing Git diff: %w", err)
+	}
+	if diff != "" {
+		diff += "\n"
+	}
+	if err := os.WriteFile(destination, []byte(diff), 0o600); err != nil {
+		return fmt.Errorf("writing Git diff: %w", err)
+	}
+	return nil
+}
+
+func appendJSONLine(path string, value any) error {
+	file, err := os.OpenFile(path, os.O_CREATE|os.O_APPEND|os.O_WRONLY, 0o600)
+	if err != nil {
+		return fmt.Errorf("opening command log: %w", err)
+	}
+	defer file.Close()
+	if err := json.NewEncoder(file).Encode(value); err != nil {
+		return fmt.Errorf("writing command log: %w", err)
+	}
+	return nil
+}
+
+func writeJSON(path string, value any) error {
+	file, err := os.OpenFile(path, os.O_CREATE|os.O_TRUNC|os.O_WRONLY, 0o600)
+	if err != nil {
+		return err
+	}
+	encoder := json.NewEncoder(file)
+	encoder.SetIndent("", "  ")
+	if err := encoder.Encode(value); err != nil {
+		file.Close()
+		return err
+	}
+	return file.Close()
+}
+
+func writeReport(path string, manifest Manifest, agent CommandResult, verification VerificationReport) error {
+	status := "FAILED"
+	if verification.Passed {
+		status = "PASSED"
+	}
+	report := fmt.Sprintf(
+		"# Evidence report: %s\n\n"+
+			"- Result: **%s**\n"+
+			"- Base commit: `%s`\n"+
+			"- Agent exit code: `%d`\n"+
+			"- Verification commands: `%d`\n"+
+			"- Initial snapshot: `%s`\n"+
+			"- Final snapshot: `%s`\n",
+		manifest.ExperimentID,
+		status,
+		manifest.BaseCommit,
+		agent.ExitCode,
+		len(verification.Commands),
+		manifest.InitialSnapshot.SHA256,
+		manifest.FinalSnapshot.SHA256,
+	)
+	return os.WriteFile(path, []byte(report), 0o600)
+}
diff --git a/internal/evidence/bundle_test.go b/internal/evidence/bundle_test.go
new file mode 100644
index 0000000..fe4982b
--- /dev/null
+++ b/internal/evidence/bundle_test.go
@@ -0,0 +1,232 @@
+package evidence
+
+import (
+	"bytes"
+	"context"
+	"encoding/json"
+	"os"
+	"os/exec"
+	"path/filepath"
+	"strings"
+	"testing"
+)
+
+func TestRunCommandMirrorsOutputWhilePreservingEvidence(t *testing.T) {
+	t.Parallel()
+
+	var progress bytes.Buffer
+	result := runCommand(
+		context.Background(),
+		t.TempDir(),
+		Command{
+			Name: "visible-agent",
+			Args: []string{"/bin/sh", "-c", "printf 'stage: analyze\\n'; printf 'stage: verify\\n' >&2"},
+		},
+		&progress,
+	)
+
+	if result.ExitCode != 0 {
+		t.Fatalf("exit code = %d, want 0", result.ExitCode)
+	}
+	if result.Stdout != "stage: analyze\n" {
+		t.Fatalf("stdout = %q", result.Stdout)
+	}
+	if result.Stderr != "stage: verify\n" {
+		t.Fatalf("stderr = %q", result.Stderr)
+	}
+	if got := progress.String(); !strings.Contains(got, "stage: analyze") || !strings.Contains(got, "stage: verify") {
+		t.Fatalf("mirrored output = %q", got)
+	}
+}
+
+func TestRunExperimentProducesReplayableEvidenceBundle(t *testing.T) {
+	t.Parallel()
+
+	repository := newFixtureRepository(t)
+	output := filepath.Join(t.TempDir(), "evidence")
+
+	result, err := RunExperiment(context.Background(), Experiment{
+		ID:         "fix-greeting",
+		Repository: repository,
+		Output:     output,
+		Agent: Command{
+			Name: "fixture-agent",
+			Args: []string{"/bin/sh", "-c", "printf 'hello, evidence\\n' > greeting.txt"},
+		},
+		Verifications: []Command{
+			{
+				Name: "greeting-test",
+				Args: []string{"/bin/sh", "-c", "test \"$(cat greeting.txt)\" = 'hello, evidence'"},
+			},
+		},
+	})
+	if err != nil {
+		t.Fatalf("RunExperiment() error = %v", err)
+	}
+	if !result.Passed {
+		t.Fatal("RunExperiment() Passed = false, want true")
+	}
+
+	for _, name := range []string{
+		"manifest.json",
+		"initial.tar",
+		"initial.patch",
+		"events.jsonl",
+		"commands.jsonl",
+		"agent.patch",
+		"verification.json",
+		"final.tar",
+		"final.patch",
+		"report.md",
+	} {
+		if _, err := os.Stat(filepath.Join(output, name)); err != nil {
+			t.Errorf("%s was not created: %v", name, err)
+		}
+	}
+
+	var manifest Manifest
+	readJSONFile(t, filepath.Join(output, "manifest.json"), &manifest)
+	if manifest.SchemaVersion != EvidenceSchemaVersion {
+		t.Errorf("SchemaVersion = %q, want %q", manifest.SchemaVersion, EvidenceSchemaVersion)
+	}
+	if manifest.InitialSnapshot.SHA256 == "" || manifest.FinalSnapshot.SHA256 == "" {
+		t.Error("snapshot hashes must be recorded")
+	}
+	if manifest.InitialSnapshot.SHA256 == manifest.FinalSnapshot.SHA256 {
+		t.Error("initial and final snapshot hashes unexpectedly match")
+	}
+
+	replay := t.TempDir()
+	if err := RestoreSnapshot(filepath.Join(output, "final.tar"), replay); err != nil {
+		t.Fatalf("RestoreSnapshot() error = %v", err)
+	}
+	content, err := os.ReadFile(filepath.Join(replay, "greeting.txt"))
+	if err != nil {
+		t.Fatal(err)
+	}
+	if string(content) != "hello, evidence\n" {
+		t.Errorf("replayed greeting = %q", content)
+	}
+}
+
+func TestRunExperimentRejectsDirtyRepository(t *testing.T) {
+	t.Parallel()
+
+	repository := newFixtureRepository(t)
+	if err := os.WriteFile(filepath.Join(repository, "dirty.txt"), []byte("not captured\n"), 0o600); err != nil {
+		t.Fatal(err)
+	}
+
+	_, err := RunExperiment(context.Background(), Experiment{
+		ID:         "dirty",
+		Repository: repository,
+		Output:     filepath.Join(t.TempDir(), "evidence"),
+		Agent:      Command{Name: "noop", Args: []string{"/usr/bin/true"}},
+	})
+	if err == nil {
+		t.Fatal("RunExperiment() error = nil, want dirty repository rejection")
+	}
+}
+
+func TestRunExperimentRejectsExistingEvidenceDirectory(t *testing.T) {
+	t.Parallel()
+
+	repository := newFixtureRepository(t)
+	output := filepath.Join(t.TempDir(), "evidence")
+	if err := os.Mkdir(output, 0o700); err != nil {
+		t.Fatal(err)
+	}
+
+	_, err := RunExperiment(context.Background(), Experiment{
+		ID:         "existing-output",
+		Repository: repository,
+		Output:     output,
+		Agent:      Command{Name: "noop", Args: []string{"/usr/bin/true"}},
+	})
+	if err == nil {
+		t.Fatal("RunExperiment() error = nil, want existing output rejection")
+	}
+}
+
+func TestRunExperimentRequiresDeterministicVerification(t *testing.T) {
+	t.Parallel()
+
+	repository := newFixtureRepository(t)
+	_, err := RunExperiment(context.Background(), Experiment{
+		ID:         "no-verification",
+		Repository: repository,
+		Output:     filepath.Join(t.TempDir(), "evidence"),
+		Agent:      Command{Name: "noop", Args: []string{"/usr/bin/true"}},
+	})
+	if err == nil {
+		t.Fatal("RunExperiment() error = nil, want missing verification rejection")
+	}
+}
+
+func TestRunExperimentRecordsFailedVerificationWithoutDiscardingEvidence(t *testing.T) {
+	t.Parallel()
+
+	repository := newFixtureRepository(t)
+	output := filepath.Join(t.TempDir(), "evidence")
+
+	result, err := RunExperiment(context.Background(), Experiment{
+		ID:         "failed-check",
+		Repository: repository,
+		Output:     output,
+		Agent:      Command{Name: "noop", Args: []string{"/usr/bin/true"}},
+		Verifications: []Command{
+			{Name: "expected-failure", Args: []string{"/usr/bin/false"}},
+		},
+	})
+	if err != nil {
+		t.Fatalf("RunExperiment() error = %v", err)
+	}
+	if result.Passed {
+		t.Fatal("RunExperiment() Passed = true, want false")
+	}
+
+	var verification VerificationReport
+	readJSONFile(t, filepath.Join(output, "verification.json"), &verification)
+	if verification.Passed || len(verification.Commands) != 1 || verification.Commands[0].ExitCode == 0 {
+		t.Fatalf("unexpected verification report: %+v", verification)
+	}
+}
+
+func newFixtureRepository(t *testing.T) string {
+	t.Helper()
+
+	root := t.TempDir()
+	runTestCommand(t, root, "git", "init", "-q")
+	runTestCommand(t, root, "git", "config", "user.email", "evidence@example.test")
+	runTestCommand(t, root, "git", "config", "user.name", "Evidence Test")
+	if err := os.WriteFile(filepath.Join(root, "greeting.txt"), []byte("hello\n"), 0o600); err != nil {
+		t.Fatal(err)
+	}
+	runTestCommand(t, root, "git", "add", "greeting.txt")
+	runTestCommand(t, root, "git", "commit", "-qm", "fixture")
+	return root
+}
+
+func runTestCommand(t *testing.T, directory, name string, args ...string) {
+	t.Helper()
+	command := exec.Command(name, args...)
+	command.Dir = directory
+	if name == "git" {
+		command.Env = isolatedGitEnvironment()
+	}
+	if output, err := command.CombinedOutput(); err != nil {
+		t.Fatalf("%s failed: %v\n%s", name, err, output)
+	}
+}
+
+func readJSONFile(t *testing.T, path string, destination any) {
+	t.Helper()
+
+	content, err := os.ReadFile(path)
+	if err != nil {
+		t.Fatal(err)
+	}
+	if err := json.Unmarshal(content, destination); err != nil {
+		t.Fatal(err)
+	}
+}
diff --git a/internal/evidence/suite.go b/internal/evidence/suite.go
new file mode 100644
index 0000000..8065cb4
--- /dev/null
+++ b/internal/evidence/suite.go
@@ -0,0 +1,309 @@
+package evidence
+
+import (
+	"context"
+	"errors"
+	"fmt"
+	"io"
+	"io/fs"
+	"os"
+	"path/filepath"
+	"regexp"
+	"sort"
+	"time"
+)
+
+const SuiteSchemaVersion = "gptcode.evidence-suite/v1"
+
+var suiteIDPattern = regexp.MustCompile(`^[a-z0-9][a-z0-9-]*$`)
+
+type Suite struct {
+	ID                string         `json:"id"`
+	Output            string         `json:"output"`
+	Repetitions       int            `json:"repetitions"`
+	RunTimeoutSeconds int            `json:"run_timeout_seconds"`
+	Setup             []Command      `json:"setup,omitempty"`
+	Agent             Command        `json:"agent"`
+	Fixtures          []SuiteFixture `json:"fixtures"`
+	Progress          io.Writer      `json:"-"`
+}
+
+type SuiteFixture struct {
+	ID                     string    `json:"id"`
+	Source                 string    `json:"source"`
+	RequireFailingBaseline bool      `json:"require_failing_baseline"`
+	Verifications          []Command `json:"verifications"`
+}
+
+type SuiteRun struct {
+	FixtureID    string        `json:"fixture_id"`
+	Repetition   int           `json:"repetition"`
+	Passed       bool          `json:"passed"`
+	TimedOut     bool          `json:"timed_out"`
+	Duration     time.Duration `json:"duration"`
+	EvidencePath string        `json:"evidence_path"`
+}
+
+type SuiteSummary struct {
+	SchemaVersion  string        `json:"schema_version"`
+	SuiteID        string        `json:"suite_id"`
+	TotalRuns      int           `json:"total_runs"`
+	PassedRuns     int           `json:"passed_runs"`
+	PassRate       float64       `json:"pass_rate"`
+	MedianDuration time.Duration `json:"median_duration"`
+	Runs           []SuiteRun    `json:"runs"`
+}
+
+// RunSuite executes every fixture and repetition sequentially. Sequential
+// execution keeps local-model resource contention from biasing comparisons.
+func RunSuite(ctx context.Context, suite Suite) (SuiteSummary, error) {
+	if err := validateSuite(suite); err != nil {
+		return SuiteSummary{}, err
+	}
+	if _, err := os.Stat(suite.Output); err == nil {
+		return SuiteSummary{}, errors.New("suite output already exists")
+	} else if !errors.Is(err, os.ErrNotExist) {
+		return SuiteSummary{}, fmt.Errorf("checking suite output: %w", err)
+	}
+	if err := os.Mkdir(suite.Output, 0o700); err != nil {
+		return SuiteSummary{}, fmt.Errorf("creating suite output: %w", err)
+	}
+	if len(suite.Setup) > 0 {
+		setup := runVerification(ctx, ".", suite.Setup)
+		if err := writeJSON(filepath.Join(suite.Output, "setup.json"), setup); err != nil {
+			return SuiteSummary{}, fmt.Errorf("writing suite setup evidence: %w", err)
+		}
+		if !setup.Passed {
+			return SuiteSummary{}, errors.New("suite setup command failed")
+		}
+	}
+
+	summary := SuiteSummary{
+		SchemaVersion: SuiteSchemaVersion,
+		SuiteID:       suite.ID,
+	}
+	var durations []time.Duration
+	for _, fixture := range suite.Fixtures {
+		for repetition := 1; repetition <= suite.Repetitions; repetition++ {
+			if err := ctx.Err(); err != nil {
+				return summary, err
+			}
+			runDirectory := filepath.Join(
+				suite.Output,
+				"runs",
+				fixture.ID,
+				fmt.Sprintf("%03d", repetition),
+			)
+			workspace := filepath.Join(runDirectory, "workspace")
+			evidencePath := filepath.Join(runDirectory, "evidence")
+			if err := os.MkdirAll(runDirectory, 0o700); err != nil {
+				return summary, fmt.Errorf("creating run directory: %w", err)
+			}
+			if err := copyFixture(fixture.Source, workspace); err != nil {
+				return summary, fmt.Errorf("copying fixture %q: %w", fixture.ID, err)
+			}
+			if err := initializeFixtureRepository(ctx, workspace); err != nil {
+				return summary, fmt.Errorf("initializing fixture %q: %w", fixture.ID, err)
+			}
+			baseline := runVerification(ctx, workspace, fixture.Verifications)
+			if err := writeJSON(filepath.Join(runDirectory, "baseline.json"), baseline); err != nil {
+				return summary, fmt.Errorf("writing fixture baseline: %w", err)
+			}
+			if fixture.RequireFailingBaseline && baseline.Passed {
+				return summary, fmt.Errorf(
+					"fixture %q repetition %d already passes its baseline",
+					fixture.ID,
+					repetition,
+				)
+			}
+
+			started := time.Now()
+			result, err := RunExperiment(ctx, Experiment{
+				ID: fmt.Sprintf(
+					"%s-%s-%03d",
+					suite.ID,
+					fixture.ID,
+					repetition,
+				),
+				Repository:    workspace,
+				Output:        evidencePath,
+				Agent:         suite.Agent,
+				Verifications: fixture.Verifications,
+				AgentTimeout:  time.Duration(suite.RunTimeoutSeconds) * time.Second,
+				Progress:      suite.Progress,
+			})
+			duration := time.Since(started)
+			if err != nil {
+				return summary, fmt.Errorf(
+					"running fixture %q repetition %d: %w",
+					fixture.ID,
+					repetition,
+					err,
+				)
+			}
+
+			relativeEvidence, err := filepath.Rel(suite.Output, evidencePath)
+			if err != nil {
+				return summary, fmt.Errorf("relativizing evidence path: %w", err)
+			}
+			run := SuiteRun{
+				FixtureID:    fixture.ID,
+				Repetition:   repetition,
+				Passed:       result.Passed,
+				TimedOut:     result.TimedOut,
+				Duration:     duration,
+				EvidencePath: filepath.ToSlash(relativeEvidence),
+			}
+			summary.Runs = append(summary.Runs, run)
+			summary.TotalRuns++
+			if result.Passed {
+				summary.PassedRuns++
+			}
+			durations = append(durations, duration)
+		}
+	}
+	if summary.TotalRuns > 0 {
+		summary.PassRate = float64(summary.PassedRuns) / float64(summary.TotalRuns)
+		summary.MedianDuration = medianDuration(durations)
+	}
+	if err := writeJSON(filepath.Join(suite.Output, "summary.json"), summary); err != nil {
+		return summary, fmt.Errorf("writing suite summary: %w", err)
+	}
+	return summary, nil
+}
+
+func runVerification(ctx context.Context, root string, commands []Command) VerificationReport {
+	report := VerificationReport{Passed: true}
+	for _, command := range commands {
+		result := runCommand(ctx, root, command)
+		report.Commands = append(report.Commands, result)
+		if result.ExitCode != 0 {
+			report.Passed = false
+		}
+	}
+	return report
+}
+
+func validateSuite(suite Suite) error {
+	if !suiteIDPattern.MatchString(suite.ID) {
+		return errors.New("suite ID must contain lowercase letters, numbers, or hyphens")
+	}
+	if suite.Output == "" {
+		return errors.New("suite output is required")
+	}
+	if suite.Repetitions < 1 {
+		return errors.New("suite repetitions must be positive")
+	}
+	if suite.RunTimeoutSeconds < 1 {
+		return errors.New("suite run timeout must be positive")
+	}
+	if suite.Agent.Name == "" || len(suite.Agent.Args) == 0 {
+		return errors.New("suite agent name and executable are required")
+	}
+	if len(suite.Fixtures) == 0 {
+		return errors.New("suite must contain at least one fixture")
+	}
+	seen := make(map[string]struct{}, len(suite.Fixtures))
+	for _, fixture := range suite.Fixtures {
+		if !suiteIDPattern.MatchString(fixture.ID) {
+			return fmt.Errorf("invalid fixture ID %q", fixture.ID)
+		}
+		if _, found := seen[fixture.ID]; found {
+			return fmt.Errorf("duplicate fixture ID %q", fixture.ID)
+		}
+		seen[fixture.ID] = struct{}{}
+		if fixture.Source == "" {
+			return fmt.Errorf("fixture %q source is required", fixture.ID)
+		}
+		if len(fixture.Verifications) == 0 {
+			return fmt.Errorf("fixture %q requires deterministic verification", fixture.ID)
+		}
+	}
+	return nil
+}
+
+func copyFixture(source, destination string) error {
+	sourceInfo, err := os.Stat(source)
+	if err != nil {
+		return err
+	}
+	if !sourceInfo.IsDir() {
+		return errors.New("fixture source must be a directory")
+	}
+	return filepath.WalkDir(source, func(path string, entry fs.DirEntry, walkErr error) error {
+		if walkErr != nil {
+			return walkErr
+		}
+		relative, err := filepath.Rel(source, path)
+		if err != nil {
+			return err
+		}
+		if relative == "." {
+			return os.Mkdir(destination, 0o700)
+		}
+		if relative == ".git" {
+			return filepath.SkipDir
+		}
+		info, err := entry.Info()
+		if err != nil {
+			return err
+		}
+		target := filepath.Join(destination, relative)
+		if info.IsDir() {
+			return os.Mkdir(target, info.Mode().Perm())
+		}
+		if !info.Mode().IsRegular() {
+			return fmt.Errorf("unsupported fixture file type at %q", relative)
+		}
+		input, err := os.Open(path)
+		if err != nil {
+			return err
+		}
+		output, err := os.OpenFile(target, os.O_CREATE|os.O_EXCL|os.O_WRONLY, info.Mode().Perm())
+		if err != nil {
+			input.Close()
+			return err
+		}
+		_, copyErr := io.Copy(output, input)
+		inputCloseErr := input.Close()
+		outputCloseErr := output.Close()
+		if copyErr != nil {
+			return copyErr
+		}
+		if inputCloseErr != nil {
+			return inputCloseErr
+		}
+		return outputCloseErr
+	})
+}
+
+func initializeFixtureRepository(ctx context.Context, root string) error {
+	commands := [][]string{
+		{"init", "--quiet"},
+		{"add", "."},
+		{
+			"-c", "user.name=GPTCode Evidence",
+			"-c", "user.email=evidence@gptcode.dev",
+			"-c", "core.hooksPath=/dev/null",
+			"commit", "--quiet", "-m", "fixture: initial state",
+		},
+	}
+	for _, args := range commands {
+		if _, err := gitOutput(ctx, root, args...); err != nil {
+			return err
+		}
+	}
+	return nil
+}
+
+func medianDuration(durations []time.Duration) time.Duration {
+	ordered := append([]time.Duration(nil), durations...)
+	sort.Slice(ordered, func(left, right int) bool {
+		return ordered[left] < ordered[right]
+	})
+	middle := len(ordered) / 2
+	if len(ordered)%2 == 1 {
+		return ordered[middle]
+	}
+	return (ordered[middle-1] + ordered[middle]) / 2
+}
diff --git a/internal/evidence/suite_test.go b/internal/evidence/suite_test.go
new file mode 100644
index 0000000..bce36c6
--- /dev/null
+++ b/internal/evidence/suite_test.go
@@ -0,0 +1,224 @@
+package evidence
+
+import (
+	"context"
+	"encoding/json"
+	"os"
+	"path/filepath"
+	"testing"
+)
+
+func TestRunSuiteExecutesEveryRepetitionAndAggregatesResults(t *testing.T) {
+	t.Parallel()
+
+	fixture := t.TempDir()
+	if err := os.WriteFile(filepath.Join(fixture, "value.txt"), []byte("before\n"), 0o600); err != nil {
+		t.Fatal(err)
+	}
+	output := filepath.Join(t.TempDir(), "suite")
+
+	summary, err := RunSuite(context.Background(), Suite{
+		ID:                "repeatability",
+		Output:            output,
+		Repetitions:       2,
+		RunTimeoutSeconds: 5,
+		Agent: Command{
+			Name: "fixture-agent",
+			Args: []string{"/bin/sh", "-c", "printf 'after\\n' > value.txt"},
+		},
+		Fixtures: []SuiteFixture{
+			{
+				ID:                     "text-change",
+				Source:                 fixture,
+				RequireFailingBaseline: true,
+				Verifications: []Command{
+					{
+						Name: "content",
+						Args: []string{"/bin/sh", "-c", "test \"$(cat value.txt)\" = after"},
+					},
+				},
+			},
+		},
+	})
+	if err != nil {
+		t.Fatalf("RunSuite() error = %v", err)
+	}
+	if summary.TotalRuns != 2 || summary.PassedRuns != 2 || summary.PassRate != 1 {
+		t.Fatalf("unexpected summary: %+v", summary)
+	}
+	if len(summary.Runs) != 2 || summary.Runs[0].Repetition != 1 || summary.Runs[1].Repetition != 2 {
+		t.Fatalf("unexpected run records: %+v", summary.Runs)
+	}
+	for _, run := range summary.Runs {
+		if _, err := os.Stat(filepath.Join(output, run.EvidencePath, "manifest.json")); err != nil {
+			t.Errorf("run evidence missing: %v", err)
+		}
+	}
+
+	var persisted SuiteSummary
+	content, err := os.ReadFile(filepath.Join(output, "summary.json"))
+	if err != nil {
+		t.Fatal(err)
+	}
+	if err := json.Unmarshal(content, &persisted); err != nil {
+		t.Fatal(err)
+	}
+	if persisted.TotalRuns != summary.TotalRuns || persisted.PassRate != summary.PassRate {
+		t.Fatalf("persisted summary = %+v, want %+v", persisted, summary)
+	}
+}
+
+func TestRunSuiteExecutesAndRecordsSetupCommands(t *testing.T) {
+	t.Parallel()
+
+	fixture := t.TempDir()
+	if err := os.WriteFile(filepath.Join(fixture, "value.txt"), []byte("before\n"), 0o600); err != nil {
+		t.Fatal(err)
+	}
+	marker := filepath.Join(t.TempDir(), "configured")
+	output := filepath.Join(t.TempDir(), "suite")
+
+	_, err := RunSuite(context.Background(), Suite{
+		ID:                "explicit-setup",
+		Output:            output,
+		Repetitions:       1,
+		RunTimeoutSeconds: 5,
+		Setup: []Command{
+			{Name: "select-profile", Args: []string{"/usr/bin/touch", marker}},
+		},
+		Agent: Command{
+			Name: "fixture-agent",
+			Args: []string{"/bin/sh", "-c", "printf 'after\\n' > value.txt"},
+		},
+		Fixtures: []SuiteFixture{
+			{
+				ID:                     "text-change",
+				Source:                 fixture,
+				RequireFailingBaseline: true,
+				Verifications: []Command{
+					{Name: "content", Args: []string{"/bin/sh", "-c", "test \"$(cat value.txt)\" = after"}},
+				},
+			},
+		},
+	})
+	if err != nil {
+		t.Fatalf("RunSuite() error = %v", err)
+	}
+	if _, err := os.Stat(marker); err != nil {
+		t.Fatalf("setup command did not execute: %v", err)
+	}
+	var setup VerificationReport
+	readJSONFile(t, filepath.Join(output, "setup.json"), &setup)
+	if !setup.Passed || len(setup.Commands) != 1 || setup.Commands[0].Name != "select-profile" {
+		t.Fatalf("setup evidence = %+v", setup)
+	}
+}
+
+func TestRunSuiteRetainsFailedRunsInAggregate(t *testing.T) {
+	t.Parallel()
+
+	fixture := t.TempDir()
+	if err := os.WriteFile(filepath.Join(fixture, "value.txt"), []byte("unchanged\n"), 0o600); err != nil {
+		t.Fatal(err)
+	}
+
+	summary, err := RunSuite(context.Background(), Suite{
+		ID:                "failure-is-evidence",
+		Output:            filepath.Join(t.TempDir(), "suite"),
+		Repetitions:       1,
+		RunTimeoutSeconds: 5,
+		Agent:             Command{Name: "noop", Args: []string{"/usr/bin/true"}},
+		Fixtures: []SuiteFixture{
+			{
+				ID:                     "failing-check",
+				Source:                 fixture,
+				RequireFailingBaseline: true,
+				Verifications: []Command{
+					{Name: "failure", Args: []string{"/usr/bin/false"}},
+				},
+			},
+		},
+	})
+	if err != nil {
+		t.Fatalf("RunSuite() error = %v", err)
+	}
+	if summary.TotalRuns != 1 || summary.PassedRuns != 0 || summary.PassRate != 0 {
+		t.Fatalf("failed run was not retained: %+v", summary)
+	}
+	if len(summary.Runs) != 1 || summary.Runs[0].Passed {
+		t.Fatalf("failed run record missing: %+v", summary.Runs)
+	}
+}
+
+func TestRunSuiteRejectsFixtureThatAlreadyPassesRequiredBaseline(t *testing.T) {
+	t.Parallel()
+
+	fixture := t.TempDir()
+	if err := os.WriteFile(filepath.Join(fixture, "value.txt"), []byte("already valid\n"), 0o600); err != nil {
+		t.Fatal(err)
+	}
+
+	_, err := RunSuite(context.Background(), Suite{
+		ID:                "green-baseline",
+		Output:            filepath.Join(t.TempDir(), "suite"),
+		Repetitions:       1,
+		RunTimeoutSeconds: 5,
+		Agent:             Command{Name: "noop", Args: []string{"/usr/bin/true"}},
+		Fixtures: []SuiteFixture{
+			{
+				ID:                     "already-passing",
+				Source:                 fixture,
+				RequireFailingBaseline: true,
+				Verifications: []Command{
+					{Name: "passes", Args: []string{"/usr/bin/true"}},
+				},
+			},
+		},
+	})
+	if err == nil {
+		t.Fatal("RunSuite() error = nil, want green baseline rejection")
+	}
+}
+
+func TestRunSuiteRecordsAgentTimeoutAndContinuesVerification(t *testing.T) {
+	t.Parallel()
+
+	fixture := t.TempDir()
+	if err := os.WriteFile(filepath.Join(fixture, "value.txt"), []byte("unchanged\n"), 0o600); err != nil {
+		t.Fatal(err)
+	}
+	output := filepath.Join(t.TempDir(), "suite")
+
+	summary, err := RunSuite(context.Background(), Suite{
+		ID:                "bounded-run",
+		Output:            output,
+		Repetitions:       1,
+		RunTimeoutSeconds: 1,
+		Agent:             Command{Name: "slow", Args: []string{"/bin/sleep", "5"}},
+		Fixtures: []SuiteFixture{
+			{
+				ID:     "timeout",
+				Source: fixture,
+				Verifications: []Command{
+					{Name: "repository-still-valid", Args: []string{"/usr/bin/true"}},
+				},
+			},
+		},
+	})
+	if err != nil {
+		t.Fatalf("RunSuite() error = %v", err)
+	}
+	if len(summary.Runs) != 1 || !summary.Runs[0].TimedOut || summary.Runs[0].Passed {
+		t.Fatalf("timeout not represented as failed evidence: %+v", summary)
+	}
+
+	var verification VerificationReport
+	readJSONFile(
+		t,
+		filepath.Join(output, summary.Runs[0].EvidencePath, "verification.json"),
+		&verification,
+	)
+	if len(verification.Commands) != 1 || verification.Commands[0].ExitCode != 0 {
+		t.Fatalf("verification did not run after timeout: %+v", verification)
+	}
+}
diff --git a/internal/llm/ollama.go b/internal/llm/ollama.go
index 696f430..68219fd 100644
--- a/internal/llm/ollama.go
+++ b/internal/llm/ollama.go
@@ -6,9 +6,11 @@ import (
 	"context"
 	"encoding/json"
 	"fmt"
+	"io"
 	"net/http"
 	"os"
 	"regexp"
+	"strconv"
 	"strings"
 	"time"
 )
@@ -32,6 +34,11 @@ type ollamaReq struct {
 	Messages []ollamaMessage `json:"messages"`
 	Stream   bool            `json:"stream"`
 	Tools    []interface{}   `json:"tools,omitempty"`
+	Options  ollamaOptions   `json:"options,omitempty"`
+}
+
+type ollamaOptions struct {
+	NumCtx int `json:"num_ctx,omitempty"`
 }
 
 type ollamaMessage struct {
@@ -82,6 +89,7 @@ func (o *OllamaProvider) ChatStream(ctx context.Context, req ChatRequest, callba
 		Messages: messages,
 		Stream:   true,
 		Tools:    req.Tools,
+		Options:  configuredOllamaOptions(),
 	}
 	b, _ := json.Marshal(body)
 
@@ -93,6 +101,10 @@ func (o *OllamaProvider) ChatStream(ctx context.Context, req ChatRequest, callba
 		return err
 	}
 	defer resp.Body.Close()
+	if resp.StatusCode < http.StatusOK || resp.StatusCode >= http.StatusMultipleChoices {
+		body, _ := io.ReadAll(io.LimitReader(resp.Body, 64*1024))
+		return fmt.Errorf("ollama returned %s: %s", resp.Status, strings.TrimSpace(string(body)))
+	}
 
 	scanner := bufio.NewScanner(resp.Body)
 	for scanner.Scan() {
@@ -145,18 +157,23 @@ func (o *OllamaProvider) Chat(ctx context.Context, req ChatRequest) (*ChatRespon
 		Messages: messages,
 		Stream:   false,
 		Tools:    req.Tools,
+		Options:  configuredOllamaOptions(),
 	}
 	b, _ := json.Marshal(body)
 
 	httpReq, _ := http.NewRequestWithContext(ctx, "POST", o.BaseURL, bytes.NewReader(b))
 	httpReq.Header.Set("Content-Type", "application/json")
 
-	client := &http.Client{Timeout: 120 * time.Second}
+	client := &http.Client{Timeout: configuredOllamaTimeout()}
 	resp, err := client.Do(httpReq)
 	if err != nil {
 		return nil, err
 	}
 	defer resp.Body.Close()
+	if resp.StatusCode < http.StatusOK || resp.StatusCode >= http.StatusMultipleChoices {
+		body, _ := io.ReadAll(io.LimitReader(resp.Body, 64*1024))
+		return nil, fmt.Errorf("ollama returned %s: %s", resp.Status, strings.TrimSpace(string(body)))
+	}
 
 	var or ollamaResp
 	if err := json.NewDecoder(resp.Body).Decode(&or); err != nil {
@@ -194,6 +211,34 @@ func (o *OllamaProvider) Chat(ctx context.Context, req ChatRequest) (*ChatRespon
 	return response, nil
 }
 
+func configuredOllamaOptions() ollamaOptions {
+	raw := strings.TrimSpace(os.Getenv("GPTCODE_OLLAMA_CONTEXT_LENGTH"))
+	if raw == "" {
+		return ollamaOptions{}
+	}
+
+	numCtx, err := strconv.Atoi(raw)
+	if err != nil || numCtx <= 0 {
+		return ollamaOptions{}
+	}
+	return ollamaOptions{NumCtx: numCtx}
+}
+
+func configuredOllamaTimeout() time.Duration {
+	const defaultTimeout = 10 * time.Minute
+
+	raw := strings.TrimSpace(os.Getenv("GPTCODE_OLLAMA_TIMEOUT"))
+	if raw == "" {
+		return defaultTimeout
+	}
+
+	timeout, err := time.ParseDuration(raw)
+	if err != nil || timeout <= 0 {
+		return defaultTimeout
+	}
+	return timeout
+}
+
 func parseXMLToolCalls(text string) []ChatToolCall {
 	var calls []ChatToolCall
 
diff --git a/internal/llm/ollama_test.go b/internal/llm/ollama_test.go
new file mode 100644
index 0000000..10a8fee
--- /dev/null
+++ b/internal/llm/ollama_test.go
@@ -0,0 +1,68 @@
+package llm
+
+import (
+	"context"
+	"encoding/json"
+	"net/http"
+	"net/http/httptest"
+	"strings"
+	"testing"
+	"time"
+)
+
+func TestOllamaChatReturnsServerErrors(t *testing.T) {
+	server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, _ *http.Request) {
+		w.Header().Set("Content-Type", "application/json")
+		w.WriteHeader(http.StatusBadRequest)
+		_, _ = w.Write([]byte(`{"error":"model is required"}`))
+	}))
+	defer server.Close()
+
+	provider := NewOllama(server.URL)
+	_, err := provider.Chat(context.Background(), ChatRequest{})
+	if err == nil || !strings.Contains(err.Error(), "model is required") {
+		t.Fatalf("expected Ollama server error, got %v", err)
+	}
+}
+
+func TestOllamaChatUsesConfiguredContextWindow(t *testing.T) {
+	t.Setenv("GPTCODE_OLLAMA_CONTEXT_LENGTH", "32768")
+
+	var request struct {
+		Options struct {
+			NumCtx int `json:"num_ctx"`
+		} `json:"options"`
+	}
+	server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		if err := json.NewDecoder(r.Body).Decode(&request); err != nil {
+			t.Fatalf("decode request: %v", err)
+		}
+		w.Header().Set("Content-Type", "application/json")
+		_, _ = w.Write([]byte(`{"message":{"content":"ok"}}`))
+	}))
+	defer server.Close()
+
+	provider := NewOllama(server.URL)
+	if _, err := provider.Chat(context.Background(), ChatRequest{Model: "local"}); err != nil {
+		t.Fatalf("Chat() error = %v", err)
+	}
+	if request.Options.NumCtx != 32768 {
+		t.Fatalf("num_ctx = %d, want 32768", request.Options.NumCtx)
+	}
+}
+
+func TestOllamaChatUsesConfiguredTimeout(t *testing.T) {
+	t.Setenv("GPTCODE_OLLAMA_TIMEOUT", "10ms")
+
+	server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, _ *http.Request) {
+		time.Sleep(100 * time.Millisecond)
+		_, _ = w.Write([]byte(`{"message":{"content":"late"}}`))
+	}))
+	defer server.Close()
+
+	provider := NewOllama(server.URL)
+	_, err := provider.Chat(context.Background(), ChatRequest{Model: "local"})
+	if err == nil || !strings.Contains(err.Error(), "context deadline exceeded") {
+		t.Fatalf("expected configured timeout, got %v", err)
+	}
+}
diff --git a/internal/maestro/conductor.go b/internal/maestro/conductor.go
index 7ac660c..bf1b760 100644
--- a/internal/maestro/conductor.go
+++ b/internal/maestro/conductor.go
@@ -236,7 +236,7 @@ func (c *Conductor) ReportCompleteWithPR(success bool, summary string, prURL str
 }
 
 // ExecuteTask orchestrates the execution of a task
-func (c *Conductor) ExecuteTask(ctx context.Context, task string, complexity string) error {
+func (c *Conductor) ExecuteTask(ctx context.Context, task string, complexity string) (taskErr error) {
 	if os.Getenv("GPTCODE_DEBUG") == "1" {
 		fmt.Fprintf(os.Stderr, "[MAESTRO] ExecuteTask called: task=%s complexity=%s lang=%s\n", task, complexity, c.language)
 	}
@@ -254,7 +254,7 @@ func (c *Conductor) ExecuteTask(ctx context.Context, task string, complexity str
 	sessionID := uuid.New().String()
 	if c.Tracer != nil {
 		_ = c.Tracer.Begin(sessionID, task)
-		defer func() { _ = c.Tracer.End(true) }() // End with success status (will be updated on error)
+		defer func() { _ = c.Tracer.End(taskErr == nil) }()
 	}
 
 	// Select model for planning
@@ -282,11 +282,15 @@ func (c *Conductor) ExecuteTask(ctx context.Context, task string, complexity str
 	// Create planner with selected model
 	planProvider := c.createProvider(planBackend)
 	planner := agents.NewPlanner(planProvider, planModel)
+	repositoryContext, err := buildPlanningRepositoryContext(c.cwd, c.language, 32*1024)
+	if err != nil {
+		return fmt.Errorf("build planning repository context: %w", err)
+	}
 
 	fmt.Println("Creating plan...")
 	c.ReportProgress("planning", "Creating plan")
 	start := time.Now()
-	plan, err := planner.CreatePlan(ctx, task, "", nil)
+	plan, err := planner.CreatePlan(ctx, task, repositoryContext, nil)
 	elapsed := time.Since(start)
 	c.ReportProgress("planning", "Plan created")
 	c.selector.RecordUsage(planBackend, planModel, err == nil, errorMsg(err))
@@ -304,10 +308,6 @@ func (c *Conductor) ExecuteTask(ctx context.Context, task string, complexity str
 	}
 
 	// Build conversation history
-	repositoryContext, err := buildEditorRepositoryContext(c.cwd, c.language, 32*1024)
-	if err != nil {
-		return fmt.Errorf("build editor repository context: %w", err)
-	}
 	history := []llm.ChatMessage{
 		{
 			Role: "user",
@@ -339,6 +339,7 @@ Do not add, remove, or rename exported symbols when API stability is required.`,
 	}
 
 	consecutiveErrors := 0
+	verificationProgress := newVerificationProgress(3)
 
 	for {
 		// Check if we should continue (intent-aware limits + loop detection)
@@ -429,9 +430,13 @@ Do not add, remove, or rename exported symbols when API stability is required.`,
 				_ = c.Tracer.RecordDecision("RecoverySystem", decision)
 			}
 
+			retryMessage, retryErr := buildRetryMessage(c.cwd, c.language, advancedPrompt)
+			if retryErr != nil {
+				return fmt.Errorf("build execution retry context: %w", retryErr)
+			}
 			history = append(history, llm.ChatMessage{
 				Role:    "user",
-				Content: advancedPrompt,
+				Content: retryMessage,
 			})
 			continue
 		}
@@ -447,6 +452,26 @@ Do not add, remove, or rename exported symbols when API stability is required.`,
 			_ = c.Tracer.RecordMetrics("EditorAgent", metrics)
 		}
 
+		if strings.EqualFold(c.language, "go") && len(modifiedFiles) > 0 {
+			formatOutput, formatErr := formatModifiedGoFiles(ctx, c.cwd, modifiedFiles)
+			if formatErr != nil {
+				feedback := fmt.Sprintf(
+					"Deterministic Go formatting failed. Fix the current implementation.\nOutput:\n%s\nError: %v",
+					formatOutput,
+					formatErr,
+				)
+				retryMessage, retryErr := buildRetryMessage(c.cwd, c.language, feedback)
+				if retryErr != nil {
+					return fmt.Errorf("build formatter retry context: %w", retryErr)
+				}
+				history = append(history, llm.ChatMessage{
+					Role:    "user",
+					Content: retryMessage,
+				})
+				continue
+			}
+		}
+
 		// Check if this is a query-only task (no validation needed)
 		if c.isQueryTask(task, plan, modifiedFiles) {
 			c.recordFeedback(editBackend, editModel, "editor", task, true, "")
@@ -458,13 +483,10 @@ Do not add, remove, or rename exported symbols when API stability is required.`,
 
 			// Print detailed execution summary
 			if c.Observer != nil {
+				c.Observer.SetOutcome(true)
 				c.Observer.PrintSummary()
 			}
 
-			// Record success metrics
-			if c.Tracer != nil {
-				_ = c.Tracer.End(true)
-			}
 			return nil
 		}
 
@@ -476,10 +498,17 @@ Do not add, remove, or rename exported symbols when API stability is required.`,
 			if changes := publicAPIChanges(publicAPIBaseline, currentPublicAPI); len(changes) > 0 {
 				issues := strings.Join(changes, "\n")
 				fmt.Printf("[WARNING] Public API contract changed:\n%s\n", issues)
+				retryMessage, retryErr := buildRetryMessage(
+					c.cwd,
+					c.language,
+					"Deterministic public API validation failed. Restore the original exported API while preserving the requested internal fix:\n"+issues,
+				)
+				if retryErr != nil {
+					return fmt.Errorf("build public API retry context: %w", retryErr)
+				}
 				history = append(history, llm.ChatMessage{
-					Role: "user",
-					Content: "Deterministic public API validation failed. Restore the original exported API while preserving the requested internal fix:\n" +
-						issues,
+					Role:    "user",
+					Content: retryMessage,
 				})
 				continue
 			}
@@ -497,10 +526,32 @@ Do not add, remove, or rename exported symbols when API stability is required.`,
 		verificationOutput, verificationErr := runRequestedVerification(ctx, c.cwd, verificationCommand)
 		if verificationErr != nil {
 			fmt.Printf("[WARNING] Deterministic verification failed:\n%s\n", verificationOutput)
-			history = append(history, llm.ChatMessage{
-				Role: "user",
-				Content: fmt.Sprintf("Deterministic verification failed. Fix the implementation and rerun the required check.\nCommand: %s\nOutput:\n%s",
+			if verificationProgress.Observe(verificationOutput) {
+				c.recordFeedback(
+					editBackend,
+					editModel,
+					"editor",
+					task,
+					false,
+					"verification plateau: "+verificationOutput,
+				)
+				return fmt.Errorf(
+					"verification plateau after %d equivalent failures; stopping without spending the remaining attempt budget",
+					verificationProgress.Consecutive(),
+				)
+			}
+			retryMessage, retryErr := buildRetryMessage(
+				c.cwd,
+				c.language,
+				fmt.Sprintf("Deterministic verification failed. Fix the implementation and rerun the required check.\nCommand: %s\nOutput:\n%s",
 					strings.Join(verificationCommand, " "), verificationOutput),
+			)
+			if retryErr != nil {
+				return fmt.Errorf("build verification retry context: %w", retryErr)
+			}
+			history = append(history, llm.ChatMessage{
+				Role:    "user",
+				Content: retryMessage,
 			})
 			continue
 		}
@@ -580,9 +631,13 @@ Output:
 				_ = c.Tracer.RecordDecision("RecoverySystem", decision)
 			}
 
+			retryMessage, retryErr := buildRetryMessage(c.cwd, c.language, advancedPrompt)
+			if retryErr != nil {
+				return fmt.Errorf("build validation retry context: %w", retryErr)
+			}
 			history = append(history, llm.ChatMessage{
 				Role:    "user",
-				Content: advancedPrompt,
+				Content: retryMessage,
 			})
 			continue
 		}
@@ -621,9 +676,13 @@ Output:
 				_ = c.Tracer.RecordDecision("RecoverySystem", decision)
 			}
 
+			retryMessage, retryErr := buildRetryMessage(c.cwd, c.language, advancedPrompt)
+			if retryErr != nil {
+				return fmt.Errorf("build review retry context: %w", retryErr)
+			}
 			history = append(history, llm.ChatMessage{
 				Role:    "user",
-				Content: advancedPrompt,
+				Content: retryMessage,
 			})
 			continue
 		}
@@ -648,13 +707,10 @@ Output:
 
 		// Print detailed execution summary
 		if c.Observer != nil {
+			c.Observer.SetOutcome(true)
 			c.Observer.PrintSummary()
 		}
 
-		// Record success metrics
-		if c.Tracer != nil {
-			_ = c.Tracer.End(true)
-		}
 		return nil
 	}
 
diff --git a/internal/maestro/formatter.go b/internal/maestro/formatter.go
new file mode 100644
index 0000000..ef52ecf
--- /dev/null
+++ b/internal/maestro/formatter.go
@@ -0,0 +1,63 @@
+package maestro
+
+import (
+	"context"
+	"errors"
+	"fmt"
+	"os/exec"
+	"path/filepath"
+	"strings"
+)
+
+func formatModifiedGoFiles(ctx context.Context, root string, modifiedFiles []string) (string, error) {
+	absoluteRoot, err := filepath.Abs(root)
+	if err != nil {
+		return "", fmt.Errorf("resolving repository root: %w", err)
+	}
+	absoluteRoot, err = filepath.EvalSymlinks(absoluteRoot)
+	if err != nil {
+		return "", fmt.Errorf("resolving repository root symlinks: %w", err)
+	}
+	var paths []string
+	seen := make(map[string]struct{}, len(modifiedFiles))
+	for _, modified := range modifiedFiles {
+		path := modified
+		if !filepath.IsAbs(path) {
+			path = filepath.Join(absoluteRoot, path)
+		}
+		path, err = filepath.Abs(path)
+		if err != nil {
+			return "", fmt.Errorf("resolving modified path: %w", err)
+		}
+		path, err = filepath.EvalSymlinks(path)
+		if err != nil {
+			return "", fmt.Errorf("resolving modified path symlinks: %w", err)
+		}
+		relative, err := filepath.Rel(absoluteRoot, path)
+		if err != nil {
+			return "", fmt.Errorf("relativizing modified path: %w", err)
+		}
+		if relative == ".." || strings.HasPrefix(relative, ".."+string(filepath.Separator)) {
+			return "", errors.New("modified file is outside repository root")
+		}
+		if filepath.Ext(relative) != ".go" {
+			continue
+		}
+		if _, found := seen[relative]; found {
+			continue
+		}
+		seen[relative] = struct{}{}
+		paths = append(paths, relative)
+	}
+	if len(paths) == 0 {
+		return "", nil
+	}
+
+	command := exec.CommandContext(ctx, "gofmt", append([]string{"-w"}, paths...)...)
+	command.Dir = absoluteRoot
+	output, err := command.CombinedOutput()
+	if err != nil {
+		return string(output), fmt.Errorf("gofmt modified files: %w", err)
+	}
+	return string(output), nil
+}
diff --git a/internal/maestro/formatter_test.go b/internal/maestro/formatter_test.go
new file mode 100644
index 0000000..1fb49ea
--- /dev/null
+++ b/internal/maestro/formatter_test.go
@@ -0,0 +1,67 @@
+package maestro
+
+import (
+	"context"
+	"os"
+	"path/filepath"
+	"testing"
+)
+
+func TestFormatModifiedGoFilesFormatsOnlyRepositoryFiles(t *testing.T) {
+	t.Parallel()
+
+	root := t.TempDir()
+	path := filepath.Join(root, "store.go")
+	if err := os.WriteFile(path, []byte("package store\n\nfunc Value( )int{return 1}\n"), 0o600); err != nil {
+		t.Fatal(err)
+	}
+
+	if _, err := formatModifiedGoFiles(context.Background(), root, []string{"store.go"}); err != nil {
+		t.Fatalf("formatModifiedGoFiles() error = %v", err)
+	}
+	content, err := os.ReadFile(path)
+	if err != nil {
+		t.Fatal(err)
+	}
+	if string(content) != "package store\n\nfunc Value() int { return 1 }\n" {
+		t.Fatalf("formatted content = %q", content)
+	}
+}
+
+func TestFormatModifiedGoFilesRejectsPathOutsideRepository(t *testing.T) {
+	t.Parallel()
+
+	root := t.TempDir()
+	outside := filepath.Join(t.TempDir(), "outside.go")
+	if err := os.WriteFile(outside, []byte("package outside\n"), 0o600); err != nil {
+		t.Fatal(err)
+	}
+
+	if _, err := formatModifiedGoFiles(context.Background(), root, []string{outside}); err == nil {
+		t.Fatal("formatModifiedGoFiles() error = nil, want outside path rejection")
+	}
+}
+
+func TestFormatModifiedGoFilesRejectsSymlinkOutsideRepository(t *testing.T) {
+	t.Parallel()
+
+	root := t.TempDir()
+	outside := filepath.Join(t.TempDir(), "outside.go")
+	if err := os.WriteFile(outside, []byte("package outside\n\nfunc Value( )int{return 1}\n"), 0o600); err != nil {
+		t.Fatal(err)
+	}
+	if err := os.Symlink(outside, filepath.Join(root, "linked.go")); err != nil {
+		t.Fatal(err)
+	}
+
+	if _, err := formatModifiedGoFiles(context.Background(), root, []string{"linked.go"}); err == nil {
+		t.Fatal("formatModifiedGoFiles() error = nil, want symlink escape rejection")
+	}
+	content, err := os.ReadFile(outside)
+	if err != nil {
+		t.Fatal(err)
+	}
+	if string(content) != "package outside\n\nfunc Value( )int{return 1}\n" {
+		t.Fatal("formatter changed file outside repository")
+	}
+}
diff --git a/internal/maestro/repository_context.go b/internal/maestro/repository_context.go
index 7d488e5..a6d3c24 100644
--- a/internal/maestro/repository_context.go
+++ b/internal/maestro/repository_context.go
@@ -58,6 +58,72 @@ func buildEditorRepositoryContext(root, language string, maxBytes int) (string,
 	return context.String(), err
 }
 
+func buildPlanningRepositoryContext(root, language string, maxBytes int) (string, error) {
+	return buildRecoveryRepositoryContext(root, language, maxBytes)
+}
+
+func buildRetryMessage(root, language, feedback string) (string, error) {
+	current, err := buildRecoveryRepositoryContext(root, language, 64*1024)
+	if err != nil {
+		return "", err
+	}
+	return fmt.Sprintf(
+		"%s\n\n## CURRENT REPOSITORY STATE AFTER THE PREVIOUS ATTEMPT\n%s\n"+
+			"Base the correction on this current state, not the original snapshot.",
+		feedback,
+		current,
+	), nil
+}
+
+// buildRecoveryRepositoryContext includes the contract that failed as well as
+// the implementation being repaired. Planning context intentionally omits test
+// files to conserve tokens, but retrying without tests leaves the editor unable
+// to reason about assertions that are only summarized by test output.
+func buildRecoveryRepositoryContext(root, language string, maxBytes int) (string, error) {
+	if maxBytes <= 0 {
+		return "", nil
+	}
+
+	var context strings.Builder
+	used := 0
+	err := filepath.WalkDir(root, func(path string, entry fs.DirEntry, walkErr error) error {
+		if walkErr != nil {
+			return walkErr
+		}
+		if entry.IsDir() {
+			switch entry.Name() {
+			case ".git", "vendor", "node_modules":
+				if path != root {
+					return filepath.SkipDir
+				}
+			}
+			return nil
+		}
+
+		name := entry.Name()
+		if !isEditorSourceFile(path, language) &&
+			name != "task.md" &&
+			name != "AGENTS.md" {
+			return nil
+		}
+		content, err := os.ReadFile(path)
+		if err != nil {
+			return err
+		}
+		if used+len(content) > maxBytes {
+			return nil
+		}
+		relative, err := filepath.Rel(root, path)
+		if err != nil {
+			return err
+		}
+		fmt.Fprintf(&context, "\n<file path=%q>\n%s\n</file>\n", filepath.ToSlash(relative), content)
+		used += len(content)
+		return nil
+	})
+	return context.String(), err
+}
+
 func isEditorSourceFile(path, language string) bool {
 	extension := strings.ToLower(filepath.Ext(path))
 	switch strings.ToLower(language) {
diff --git a/internal/maestro/repository_context_test.go b/internal/maestro/repository_context_test.go
index 81c243e..f46fbf7 100644
--- a/internal/maestro/repository_context_test.go
+++ b/internal/maestro/repository_context_test.go
@@ -27,3 +27,52 @@ func TestBuildEditorRepositoryContextIncludesImplementation(t *testing.T) {
 		t.Fatalf("test file should not consume editor context: %s", context)
 	}
 }
+
+func TestBuildPlanningRepositoryContextGroundsPlanInImplementation(t *testing.T) {
+	root := t.TempDir()
+	if err := os.WriteFile(filepath.Join(root, "ledger.go"), []byte("package ledger\nfunc Transfer() {}\n"), 0o644); err != nil {
+		t.Fatal(err)
+	}
+	if err := os.WriteFile(filepath.Join(root, "ledger_test.go"), []byte("package ledger\nfunc TestTransferPreservesTotal() {}\n"), 0o644); err != nil {
+		t.Fatal(err)
+	}
+	if err := os.WriteFile(filepath.Join(root, "task.md"), []byte("Keep the public API stable.\n"), 0o644); err != nil {
+		t.Fatal(err)
+	}
+
+	context, err := buildPlanningRepositoryContext(root, "Go", 32*1024)
+	if err != nil {
+		t.Fatal(err)
+	}
+	if !strings.Contains(context, `path="ledger.go"`) ||
+		!strings.Contains(context, "func Transfer") ||
+		!strings.Contains(context, "TestTransferPreservesTotal") ||
+		!strings.Contains(context, "Keep the public API stable") {
+		t.Fatalf("planning evidence missing: %s", context)
+	}
+}
+
+func TestBuildRetryMessageIncludesCurrentRepositoryState(t *testing.T) {
+	root := t.TempDir()
+	if err := os.WriteFile(filepath.Join(root, "ledger.go"), []byte("package ledger\nvar attempt = 2\n"), 0o644); err != nil {
+		t.Fatal(err)
+	}
+	if err := os.WriteFile(filepath.Join(root, "ledger_test.go"), []byte("package ledger\nfunc TestTransferContract() {}\n"), 0o644); err != nil {
+		t.Fatal(err)
+	}
+	if err := os.WriteFile(filepath.Join(root, "task.md"), []byte("Preserve the exported API and pass the race detector.\n"), 0o644); err != nil {
+		t.Fatal(err)
+	}
+
+	message, err := buildRetryMessage(root, "Go", "go test failed")
+	if err != nil {
+		t.Fatal(err)
+	}
+	if !strings.Contains(message, "go test failed") ||
+		!strings.Contains(message, "CURRENT REPOSITORY STATE") ||
+		!strings.Contains(message, "var attempt = 2") ||
+		!strings.Contains(message, "TestTransferContract") ||
+		!strings.Contains(message, "Preserve the exported API") {
+		t.Fatalf("retry message lacks current evidence: %s", message)
+	}
+}
diff --git a/internal/maestro/verification_progress.go b/internal/maestro/verification_progress.go
new file mode 100644
index 0000000..3e15044
--- /dev/null
+++ b/internal/maestro/verification_progress.go
@@ -0,0 +1,55 @@
+package maestro
+
+import (
+	"regexp"
+	"strings"
+)
+
+var (
+	verificationDuration = regexp.MustCompile(`\d+(?:\.\d+)?s\b`)
+	goTestTemporaryPath  = regexp.MustCompile(
+		`(?:/private)?/var/folders/[^[:space:]]+/T/Test[^/[:space:]]+[0-9]+/[0-9]+|/tmp/Test[^/[:space:]]+[0-9]+/[0-9]+`,
+	)
+)
+
+type verificationProgress struct {
+	threshold   int
+	lastFailure string
+	consecutive int
+}
+
+func newVerificationProgress(threshold int) *verificationProgress {
+	if threshold < 1 {
+		threshold = 1
+	}
+	return &verificationProgress{threshold: threshold}
+}
+
+func (p *verificationProgress) Observe(output string) bool {
+	failure := normalizeVerificationFailure(output)
+	if failure == p.lastFailure && failure != "" {
+		p.consecutive++
+	} else {
+		p.lastFailure = failure
+		p.consecutive = 1
+	}
+	return failure != "" && p.consecutive >= p.threshold
+}
+
+func (p *verificationProgress) Consecutive() int {
+	return p.consecutive
+}
+
+func normalizeVerificationFailure(output string) string {
+	output = verificationDuration.ReplaceAllString(output, "(duration)")
+	output = goTestTemporaryPath.ReplaceAllString(output, "(go-test-temp)")
+	lines := strings.Split(output, "\n")
+	normalized := make([]string, 0, len(lines))
+	for _, line := range lines {
+		line = strings.Join(strings.Fields(line), " ")
+		if line != "" {
+			normalized = append(normalized, line)
+		}
+	}
+	return strings.Join(normalized, "\n")
+}
diff --git a/internal/maestro/verification_progress_test.go b/internal/maestro/verification_progress_test.go
new file mode 100644
index 0000000..5140831
--- /dev/null
+++ b/internal/maestro/verification_progress_test.go
@@ -0,0 +1,57 @@
+package maestro
+
+import "testing"
+
+func TestVerificationProgressStopsAfterThreeEquivalentFailures(t *testing.T) {
+	tracker := newVerificationProgress(3)
+	outputs := []string{
+		"--- FAIL: TestWriteRejectsSymlinkedParent (0.00s)\nFAIL example.com/safestore 0.295s\n",
+		"--- FAIL: TestWriteRejectsSymlinkedParent (0.01s)\nFAIL example.com/safestore 0.420s\n",
+		"--- FAIL: TestWriteRejectsSymlinkedParent (0.02s)\nFAIL example.com/safestore 0.362s\n",
+	}
+
+	for index, output := range outputs {
+		plateau := tracker.Observe(output)
+		if index < 2 && plateau {
+			t.Fatalf("reported plateau after only %d observations", index+1)
+		}
+		if index == 2 && !plateau {
+			t.Fatal("expected three equivalent failures to report a plateau")
+		}
+	}
+}
+
+func TestVerificationProgressResetsWhenFailureChanges(t *testing.T) {
+	tracker := newVerificationProgress(3)
+	if tracker.Observe("undefined: unsafe") {
+		t.Fatal("first failure cannot be a plateau")
+	}
+	if tracker.Observe("undefined: unsafe") {
+		t.Fatal("second failure cannot be a plateau")
+	}
+	if tracker.Observe("TestSelfTransferCompletes: self-transfer deadlocked") {
+		t.Fatal("a changed failure is progress, not a plateau")
+	}
+	if tracker.Consecutive() != 1 {
+		t.Fatalf("consecutive failures = %d, want reset to 1", tracker.Consecutive())
+	}
+}
+
+func TestVerificationProgressIgnoresGoTemporaryDirectoryIDs(t *testing.T) {
+	tracker := newVerificationProgress(3)
+	outputs := []string{
+		"Write() error = lstat /private/var/folders/aa/one/T/TestWriteStoresNestedFileInsideRoot1722907079/001/reports: no such file\n",
+		"Write() error = lstat /private/var/folders/bb/two/T/TestWriteStoresNestedFileInsideRoot3193033618/001/reports: no such file\n",
+		"Write() error = lstat /private/var/folders/cc/three/T/TestWriteStoresNestedFileInsideRoot1568810318/001/reports: no such file\n",
+	}
+
+	for index, output := range outputs {
+		plateau := tracker.Observe(output)
+		if index < 2 && plateau {
+			t.Fatalf("reported plateau after only %d observations", index+1)
+		}
+		if index == 2 && !plateau {
+			t.Fatal("temporary directory IDs must not disguise an equivalent failure")
+		}
+	}
+}
diff --git a/internal/modes/model_selection.go b/internal/modes/model_selection.go
new file mode 100644
index 0000000..7b2d2ae
--- /dev/null
+++ b/internal/modes/model_selection.go
@@ -0,0 +1,7 @@
+package modes
+
+import "github.com/jadercorrea/gptcode/internal/config"
+
+func configuredAgentModel(backend config.BackendConfig, profile, agent string) string {
+	return backend.GetModelForAgentWithProfile(agent, profile)
+}
diff --git a/internal/modes/model_selection_test.go b/internal/modes/model_selection_test.go
new file mode 100644
index 0000000..c6560bd
--- /dev/null
+++ b/internal/modes/model_selection_test.go
@@ -0,0 +1,28 @@
+package modes
+
+import (
+	"testing"
+
+	"github.com/jadercorrea/gptcode/internal/config"
+)
+
+func TestConfiguredAgentModelUsesActiveBackendProfile(t *testing.T) {
+	backend := config.BackendConfig{
+		DefaultModel: "fallback",
+		Profiles: map[string]config.ProfileConfig{
+			"evaluation": {
+				AgentModels: config.AgentModels{
+					Query:    "qwen-query",
+					Research: "qwen-research",
+				},
+			},
+		},
+	}
+
+	if got := configuredAgentModel(backend, "evaluation", "query"); got != "qwen-query" {
+		t.Fatalf("query model = %q, want profile model", got)
+	}
+	if got := configuredAgentModel(backend, "evaluation", "research"); got != "qwen-research" {
+		t.Fatalf("research model = %q, want profile model", got)
+	}
+}
diff --git a/internal/modes/research.go b/internal/modes/research.go
index 59db520..7e635da 100644
--- a/internal/modes/research.go
+++ b/internal/modes/research.go
@@ -19,6 +19,8 @@ import (
 	"golang.org/x/term"
 )
 
+const localModelTimeout = 2 * time.Minute
+
 func RunResearch(args []string) error {
 	question := ""
 	if len(args) > 0 {
@@ -78,7 +80,7 @@ func RunResearch(args []string) error {
 		customExec = llm.NewChatCompletion(backendCfg.BaseURL, backendName)
 	}
 
-	queryModel := backendCfg.GetModelForAgent("query")
+	queryModel := configuredAgentModel(backendCfg, setup.Defaults.Profile, "research")
 	queryAgent := agents.NewQuery(customExec, cwd, queryModel)
 
 	evidence, err := collectRepositoryEvidence(cwd, question)
@@ -86,7 +88,7 @@ func RunResearch(args []string) error {
 		return fmt.Errorf("collect repository evidence: %w", err)
 	}
 	codebasePrompt := buildCodebaseResearchPrompt(question, evidence)
-	researchCtx, cancel := context.WithTimeout(context.Background(), 45*time.Second)
+	researchCtx, cancel := context.WithTimeout(context.Background(), localModelTimeout)
 	defer cancel()
 
 	codebaseAnalysis, err := queryAgent.Execute(researchCtx, []llm.ChatMessage{{Role: "user", Content: codebasePrompt}}, nil)
@@ -110,6 +112,41 @@ override the implementation evidence.`
 		}
 	}
 
+	for correctionAttempt := 0; correctionAttempt < 2; correctionAttempt++ {
+		issues := unsupportedGoLockClaims(codebaseAnalysis, evidence)
+		if ciIssue := unsupportedCIClaim(codebaseAnalysis, evidence); ciIssue != "" {
+			issues = append(issues, ciIssue)
+		}
+		if len(issues) == 0 {
+			break
+		}
+		correctionCtx, correctionCancel := context.WithTimeout(context.Background(), localModelTimeout)
+		corrected, correctionErr := queryAgent.Execute(correctionCtx, []llm.ChatMessage{{
+			Role: "user",
+			Content: buildCodebaseResearchPrompt(question, evidence) + fmt.Sprintf(`
+
+Mandatory correction:
+The draft made these claims that contradict the inspected repository evidence:
+- %s
+
+Rewrite the answer from scratch. Describe the exact lock acquired by each
+method separately. Return only Findings, Evidence, and Verification; do not
+include the previous draft or a corrections appendix.`, strings.Join(issues, "\n- ")),
+		}}, nil)
+		correctionCancel()
+		if correctionErr != nil {
+			return fmt.Errorf("correct unsupported lock claims: %w", correctionErr)
+		}
+		codebaseAnalysis = corrected
+	}
+	remainingIssues := unsupportedGoLockClaims(codebaseAnalysis, evidence)
+	if ciIssue := unsupportedCIClaim(codebaseAnalysis, evidence); ciIssue != "" {
+		remainingIssues = append(remainingIssues, ciIssue)
+	}
+	if len(remainingIssues) > 0 {
+		return fmt.Errorf("codebase analysis contradicted deterministic evidence: %s", strings.Join(remainingIssues, "; "))
+	}
+
 	home, _ := os.UserHomeDir()
 	researchDir := filepath.Join(home, ".gptcode", "research")
 	_ = os.MkdirAll(researchDir, 0755)
@@ -181,6 +218,61 @@ func contradictsUnsafeConcurrencyEvidence(analysis string, evidence repositoryEv
 	return claimsSafe && !acknowledgesUnsafe
 }
 
+func unsupportedGoLockClaims(analysis string, evidence repositoryEvidence) []string {
+	if !strings.EqualFold(evidence.Language, "Go") {
+		return nil
+	}
+
+	methodUsesReadLock := make(map[string]bool)
+	methodPattern := regexp.MustCompile(`(?s)func\s+\([^)]*\)\s+([A-Za-z][A-Za-z0-9_]*)\([^)]*\)[^{]*\{(.*?)\n\}`)
+	for _, content := range evidence.Contents {
+		for _, match := range methodPattern.FindAllStringSubmatch(content, -1) {
+			if len(match) == 3 {
+				methodUsesReadLock[match[1]] = strings.Contains(match[2], ".RLock()")
+			}
+		}
+	}
+
+	var issues []string
+	segments := strings.FieldsFunc(analysis, func(r rune) bool {
+		return r == '\n' || r == ';'
+	})
+	for _, segment := range segments {
+		lower := strings.ToLower(segment)
+		if !strings.Contains(lower, "read lock") && !strings.Contains(lower, "rlock") {
+			continue
+		}
+		for method, usesReadLock := range methodUsesReadLock {
+			if usesReadLock {
+				continue
+			}
+			methodPattern := regexp.MustCompile(`(?i)\b` + regexp.QuoteMeta(method) + `\b`)
+			if methodPattern.MatchString(segment) {
+				issues = append(issues, fmt.Sprintf("%s does not acquire RLock, but the draft says: %s", method, strings.TrimSpace(segment)))
+			}
+		}
+	}
+	sort.Strings(issues)
+	return issues
+}
+
+func unsupportedCIClaim(analysis string, evidence repositoryEvidence) string {
+	mentionsCI := regexp.MustCompile(`(?i)\bCI(?:/CD)?\b`).MatchString(analysis)
+	if !mentionsCI {
+		return ""
+	}
+	for _, path := range evidence.Files {
+		lower := strings.ToLower(path)
+		if strings.HasPrefix(lower, ".github/workflows/") ||
+			strings.Contains(lower, "gitlab-ci") ||
+			strings.Contains(lower, "circleci") ||
+			strings.Contains(lower, "buildkite") {
+			return ""
+		}
+	}
+	return "the draft claims CI execution, but no CI configuration exists in the inspected evidence"
+}
+
 type repositoryEvidence struct {
 	Language string
 	Files    []string
@@ -335,7 +427,7 @@ func buildCodebaseResearchPrompt(question string, evidence repositoryEvidence) s
 		if !ok {
 			continue
 		}
-		fmt.Fprintf(&groundedFiles, "\n<file path=%q>\n%s\n</file>\n", path, content)
+		fmt.Fprintf(&groundedFiles, "\n<file path=%q>\n%s\n</file>\n", path, numberLines(content))
 	}
 
 	return fmt.Sprintf(`Research this repository question:
@@ -360,6 +452,8 @@ Grounding requirements:
 8. Compare stated expectations with implementation details and report contradictions explicitly.
 9. Concurrency claims require synchronization in the implementation (for example locks, atomics, channels, or documented confinement). A WaitGroup or goroutines in a test exercise concurrency; they do not make shared state safe.
 10. If mutable shared state has no visible synchronization, state that concurrent access is unsafe and recommend running the repository's race/concurrency verification.
+11. Make the answer internally consistent. Describe the lock actually acquired by each method; do not classify a method as a read operation if its implementation takes a write lock or mutates state.
+12. Do not claim a command passed unless its exit status and output are included in the evidence. Distinguish commands required by the repository from commands actually executed.
 
 Return concise sections: Findings, Evidence, Verification.`, question, evidence.Language, strings.Join(evidence.Files, "\n"), groundedFiles.String())
 }
diff --git a/internal/modes/research_test.go b/internal/modes/research_test.go
index a0bfc1c..1477445 100644
--- a/internal/modes/research_test.go
+++ b/internal/modes/research_test.go
@@ -71,6 +71,7 @@ func TestBuildCodebaseResearchPromptRequiresGroundedEvidence(t *testing.T) {
 		"session/store.go",
 		"session/store_test.go",
 		"func (s *Store) Active",
+		`1 | func (s *Store) Active`,
 		"read_file",
 		"exact file paths",
 		"Do not speculate",
@@ -80,6 +81,8 @@ func TestBuildCodebaseResearchPromptRequiresGroundedEvidence(t *testing.T) {
 		"report contradictions",
 		"Concurrency claims require synchronization in the implementation",
 		"WaitGroup or goroutines in a test exercise concurrency",
+		"internally consistent",
+		"Do not claim a command passed",
 	} {
 		if !strings.Contains(prompt, required) {
 			t.Fatalf("research prompt missing %q:\n%s", required, prompt)
@@ -131,6 +134,52 @@ func TestResearchDetectsUnsupportedConcurrencySafetyClaim(t *testing.T) {
 	}
 }
 
+func TestResearchDetectsUnsupportedGoMethodLockClaim(t *testing.T) {
+	evidence := repositoryEvidence{
+		Language: "Go",
+		Contents: map[string]string{
+			"cache.go": `package cache
+func (c *Cache) Get() {
+	c.mu.RLock()
+	defer c.mu.RUnlock()
+}
+func (c *Cache) Len() int {
+	c.mu.Lock()
+	defer c.mu.Unlock()
+	return 0
+}`,
+		},
+	}
+
+	issues := unsupportedGoLockClaims(
+		"Read operations (`Get`, `Len`) acquire read locks (`RLock`).",
+		evidence,
+	)
+	if len(issues) != 1 || !strings.Contains(issues[0], "Len") {
+		t.Fatalf("expected the false Len lock claim to be rejected, got %v", issues)
+	}
+	if issues := unsupportedGoLockClaims(
+		"`Get` starts with RLock; `Len` takes the exclusive Lock because it deletes expired entries.",
+		evidence,
+	); len(issues) != 0 {
+		t.Fatalf("expected exact per-method lock claims to pass, got %v", issues)
+	}
+}
+
+func TestResearchRejectsCIClaimsWithoutCIEvidence(t *testing.T) {
+	evidence := repositoryEvidence{
+		Files: []string{"cache.go", "cache_test.go", "task.md"},
+	}
+	if issue := unsupportedCIClaim("These commands are executed by the repository's CI system.", evidence); issue == "" {
+		t.Fatal("expected unsupported CI claim to be rejected")
+	}
+
+	evidence.Files = append(evidence.Files, ".github/workflows/verify.yml")
+	if issue := unsupportedCIClaim("These commands are executed by CI.", evidence); issue != "" {
+		t.Fatalf("expected CI claim with workflow evidence to pass, got %q", issue)
+	}
+}
+
 func TestCollectRepositoryEvidenceStaysInsidePublicRepositoryContext(t *testing.T) {
 	repository := t.TempDir()
 	outside := t.TempDir()
diff --git a/internal/modes/review.go b/internal/modes/review.go
index 4d76d81..1814c3c 100644
--- a/internal/modes/review.go
+++ b/internal/modes/review.go
@@ -5,8 +5,8 @@ import (
 	"fmt"
 	"os"
 	"path/filepath"
+	"sort"
 	"strings"
-	"time"
 
 	"github.com/jadercorrea/gptcode/internal/agents"
 	"github.com/jadercorrea/gptcode/internal/config"
@@ -27,7 +27,7 @@ func RunReview(opts ReviewOptions) error {
 	backendName := setup.Defaults.Backend
 
 	backendCfg := setup.Backend[backendName]
-	model := backendCfg.GetModelForAgent("query")
+	model := configuredAgentModel(backendCfg, setup.Defaults.Profile, "query")
 	if model == "" {
 		model = backendCfg.DefaultModel
 	}
@@ -60,14 +60,20 @@ func RunReview(opts ReviewOptions) error {
 	}
 
 	var fileEvidence string
+	var relatedEvidence string
 	if !info.IsDir() {
 		content, err := os.ReadFile(targetPath)
 		if err != nil {
 			return fmt.Errorf("read review target: %w", err)
 		}
 		fileEvidence = string(content)
+		evidence, evidenceErr := collectRepositoryEvidence(cwd, target+" "+opts.Focus)
+		if evidenceErr != nil {
+			return fmt.Errorf("collect review evidence: %w", evidenceErr)
+		}
+		relatedEvidence = formatRelatedReviewEvidence(cwd, targetPath, evidence)
 	}
-	reviewPrompt := buildReviewPrompt(targetPath, info.IsDir(), opts.Focus, fileEvidence)
+	reviewPrompt := buildReviewPrompt(targetPath, info.IsDir(), opts.Focus, fileEvidence, relatedEvidence)
 
 	fmt.Printf("Reviewing: %s\n", target)
 	if opts.Focus != "" {
@@ -86,7 +92,7 @@ func RunReview(opts ReviewOptions) error {
 		},
 	}
 
-	ctx, cancel := context.WithTimeout(context.Background(), 45*time.Second)
+	ctx, cancel := context.WithTimeout(context.Background(), localModelTimeout)
 	defer cancel()
 	var result string
 	if fileEvidence != "" {
@@ -121,7 +127,7 @@ func RunReview(opts ReviewOptions) error {
 	return nil
 }
 
-func buildReviewPrompt(targetPath string, isDir bool, focus string, fileEvidence string) string {
+func buildReviewPrompt(targetPath string, isDir bool, focus, fileEvidence, relatedEvidence string) string {
 	var prompt strings.Builder
 
 	if isDir {
@@ -133,6 +139,11 @@ func buildReviewPrompt(targetPath string, isDir bool, focus string, fileEvidence
 		prompt.WriteString("```text\n")
 		prompt.WriteString(numberLines(fileEvidence))
 		prompt.WriteString("\n```\n")
+		if relatedEvidence != "" {
+			prompt.WriteString("\nRelated repository contracts and tests:\n")
+			prompt.WriteString(relatedEvidence)
+			prompt.WriteString("\n")
+		}
 	}
 
 	if focus != "" {
@@ -150,10 +161,40 @@ func buildReviewPrompt(targetPath string, isDir bool, focus string, fileEvidence
 	prompt.WriteString("Do not invent lifecycle requirements, background work, or new public API methods. When the requested focus is satisfied and no defect is evidenced, say so explicitly.\n")
 	prompt.WriteString("Treat an evidenced violation of the requested focus as a defect even if no broader product requirements were supplied.\n")
 	prompt.WriteString("Private implementation changes do not alter the public API; do not claim that adding private synchronization changes exported constructors or methods.\n")
+	prompt.WriteString("Reserve Critical Issues for a demonstrated failing input, unsafe interleaving, security boundary violation, or broken contract; place simplifications and micro-optimizations under Suggestions.\n")
+	prompt.WriteString("Go visibility is determined by capitalization; do not recommend underscore prefixes for private identifiers.\n")
+	prompt.WriteString("When reasoning about concurrency, an exclusive lock prevents concurrent map mutation for its duration. Do not invent a race or deadlock without showing a concrete interleaving from the supplied code.\n")
 
 	return prompt.String()
 }
 
+func formatRelatedReviewEvidence(cwd, targetPath string, evidence repositoryEvidence) string {
+	targetRelative, err := filepath.Rel(cwd, targetPath)
+	if err != nil {
+		return ""
+	}
+	targetRelative = filepath.ToSlash(targetRelative)
+
+	paths := make([]string, 0, len(evidence.Contents))
+	for path := range evidence.Contents {
+		if path != targetRelative {
+			paths = append(paths, path)
+		}
+	}
+	sort.Strings(paths)
+
+	var related strings.Builder
+	for _, path := range paths {
+		fmt.Fprintf(
+			&related,
+			"\n<file path=%q>\n%s\n</file>\n",
+			path,
+			numberLines(evidence.Contents[path]),
+		)
+	}
+	return related.String()
+}
+
 func numberLines(content string) string {
 	lines := strings.Split(strings.TrimSuffix(content, "\n"), "\n")
 	var numbered strings.Builder
diff --git a/internal/modes/review_test.go b/internal/modes/review_test.go
index 007a70a..bcc43e4 100644
--- a/internal/modes/review_test.go
+++ b/internal/modes/review_test.go
@@ -1,6 +1,7 @@
 package modes
 
 import (
+	"path/filepath"
 	"strings"
 	"testing"
 )
@@ -11,6 +12,7 @@ func TestBuildReviewPromptIncludesFileEvidenceAndConstraints(t *testing.T) {
 		false,
 		"concurrency correctness and public API stability",
 		"package session\n\ntype Store struct { sessions map[string]Session }\n",
+		"<file path=\"task.md\">\n1 | Preserve the public API.\n</file>",
 	)
 
 	for _, required := range []string{
@@ -24,9 +26,40 @@ func TestBuildReviewPromptIncludesFileEvidenceAndConstraints(t *testing.T) {
 		"Treat an evidenced violation of the requested focus as a defect",
 		"Private implementation changes do not alter the public API",
 		"1 | package session",
+		`path="task.md"`,
+		"Preserve the public API",
+		"Reserve Critical Issues",
+		"Go visibility is determined by capitalization",
+		"exclusive lock prevents concurrent map mutation",
 	} {
 		if !strings.Contains(prompt, required) {
 			t.Fatalf("review prompt missing %q:\n%s", required, prompt)
 		}
 	}
 }
+
+func TestFormatRelatedReviewEvidenceExcludesTargetAndNumbersContracts(t *testing.T) {
+	root := t.TempDir()
+	target := filepath.Join(root, "cache.go")
+	formatted := formatRelatedReviewEvidence(root, target, repositoryEvidence{
+		Contents: map[string]string{
+			"cache.go":      "package cache\n",
+			"cache_test.go": "package cache\nfunc TestExpiry() {}\n",
+			"task.md":       "Run go test -race ./...\n",
+		},
+	})
+
+	if strings.Contains(formatted, `path="cache.go"`) {
+		t.Fatalf("target was duplicated in related evidence: %s", formatted)
+	}
+	for _, required := range []string{
+		`path="cache_test.go"`,
+		"2 | func TestExpiry",
+		`path="task.md"`,
+		"1 | Run go test -race ./...",
+	} {
+		if !strings.Contains(formatted, required) {
+			t.Fatalf("related evidence missing %q: %s", required, formatted)
+		}
+	}
+}
diff --git a/internal/observability/observer.go b/internal/observability/observer.go
index 619bdb1..531411c 100644
--- a/internal/observability/observer.go
+++ b/internal/observability/observer.go
@@ -129,6 +129,10 @@ type Observer interface {
 
 	// SetVerbose enables real-time console output
 	SetVerbose(verbose bool)
+
+	// SetOutcome records the authoritative final task outcome. Recoverable
+	// intermediate errors remain available as diagnostic evidence.
+	SetOutcome(success bool)
 }
 
 // AgentObserver is the concrete implementation of Observer
@@ -151,6 +155,7 @@ type AgentObserver struct {
 	totalCost     float64
 	errors        []string
 	success       bool
+	outcomeSet    bool
 	tokensSaved   int
 	costSaved     float64
 	activeModel   string
@@ -325,12 +330,20 @@ func (o *AgentObserver) Summary() *ExecutionSummary {
 		TokensOut:     o.tokensOut,
 		TotalCost:     o.totalCost,
 		Errors:        o.errors,
-		Success:       o.success && len(o.errors) == 0,
+		Success:       o.success && (o.outcomeSet || len(o.errors) == 0),
 		TokensSaved:   o.tokensSaved,
 		CostSaved:     o.costSaved,
 	}
 }
 
+// SetOutcome records the authoritative result after retries and verification.
+func (o *AgentObserver) SetOutcome(success bool) {
+	o.mu.Lock()
+	defer o.mu.Unlock()
+	o.success = success
+	o.outcomeSet = true
+}
+
 // Subscribe adds a channel to receive events
 func (o *AgentObserver) Subscribe(ch chan<- Event) {
 	o.mu.Lock()
diff --git a/internal/observability/observer_test.go b/internal/observability/observer_test.go
index a58eac7..997d8a0 100644
--- a/internal/observability/observer_test.go
+++ b/internal/observability/observer_test.go
@@ -14,3 +14,26 @@ func TestSummaryTracksToolDurationSeparatelyFromTaskDuration(t *testing.T) {
 		t.Fatalf("expected 25ms of tool time, got %s", summary.ToolDuration)
 	}
 }
+
+func TestFinalOutcomeOverridesRecoverableIntermediateErrors(t *testing.T) {
+	observer := NewObserver()
+	observer.Emit(&ToolCallEvent{Name: "run_command", Error: "tests failed"})
+	observer.SetOutcome(true)
+
+	summary := observer.Summary()
+	if !summary.Success {
+		t.Fatal("successful final outcome must not be reported as failed")
+	}
+	if len(summary.Errors) != 1 {
+		t.Fatalf("errors = %v, want recoverable error retained", summary.Errors)
+	}
+}
+
+func TestSummaryWithErrorFailsBeforeFinalOutcome(t *testing.T) {
+	observer := NewObserver()
+	observer.Emit(&ToolCallEvent{Name: "run_command", Error: "tests failed"})
+
+	if observer.Summary().Success {
+		t.Fatal("intermediate errors must fail a summary without a final outcome")
+	}
+}
diff --git a/scripts/evidence-run/main.go b/scripts/evidence-run/main.go
new file mode 100644
index 0000000..39d4eb5
--- /dev/null
+++ b/scripts/evidence-run/main.go
@@ -0,0 +1,48 @@
+// Command evidence-run executes a controlled agent experiment and writes an
+// inspectable, replayable evidence bundle.
+package main
+
+import (
+	"context"
+	"encoding/json"
+	"flag"
+	"fmt"
+	"os"
+
+	"github.com/jadercorrea/gptcode/internal/evidence"
+)
+
+func main() {
+	configPath := flag.String("config", "", "path to an experiment JSON file")
+	flag.Parse()
+	if *configPath == "" {
+		fmt.Fprintln(os.Stderr, "usage: evidence-run -config <experiment.json>")
+		os.Exit(2)
+	}
+
+	file, err := os.Open(*configPath)
+	if err != nil {
+		fmt.Fprintln(os.Stderr, "opening experiment configuration failed")
+		os.Exit(1)
+	}
+	defer file.Close()
+
+	var experiment evidence.Experiment
+	decoder := json.NewDecoder(file)
+	decoder.DisallowUnknownFields()
+	if err := decoder.Decode(&experiment); err != nil {
+		fmt.Fprintln(os.Stderr, "decoding experiment configuration failed")
+		os.Exit(1)
+	}
+
+	result, err := evidence.RunExperiment(context.Background(), experiment)
+	if err != nil {
+		fmt.Fprintln(os.Stderr, "experiment failed safely")
+		os.Exit(1)
+	}
+	if !result.Passed {
+		fmt.Fprintln(os.Stderr, "experiment completed with failed verification")
+		os.Exit(1)
+	}
+	fmt.Println("experiment completed with verified evidence")
+}
diff --git a/scripts/evidence-suite/main.go b/scripts/evidence-suite/main.go
new file mode 100644
index 0000000..ba633d7
--- /dev/null
+++ b/scripts/evidence-suite/main.go
@@ -0,0 +1,65 @@
+// Command evidence-suite repeats controlled agent experiments across a
+// versioned fixture corpus and writes an aggregate, failure-inclusive report.
+package main
+
+import (
+	"context"
+	"encoding/json"
+	"flag"
+	"fmt"
+	"os"
+
+	"github.com/jadercorrea/gptcode/internal/evidence"
+)
+
+func main() {
+	configPath := flag.String("config", "", "path to a suite JSON file")
+	output := flag.String("output", "", "override suite output directory")
+	repetitions := flag.Int("repetitions", 0, "override repetitions per fixture")
+	verbose := flag.Bool("verbose", false, "stream agent progress while preserving evidence")
+	flag.Parse()
+	if *configPath == "" {
+		fmt.Fprintln(os.Stderr, "usage: evidence-suite -config <suite.json>")
+		os.Exit(2)
+	}
+
+	file, err := os.Open(*configPath)
+	if err != nil {
+		fmt.Fprintln(os.Stderr, "opening suite configuration failed")
+		os.Exit(1)
+	}
+	defer file.Close()
+
+	var suite evidence.Suite
+	decoder := json.NewDecoder(file)
+	decoder.DisallowUnknownFields()
+	if err := decoder.Decode(&suite); err != nil {
+		fmt.Fprintln(os.Stderr, "decoding suite configuration failed")
+		os.Exit(1)
+	}
+	if *output != "" {
+		suite.Output = *output
+	}
+	if *repetitions > 0 {
+		suite.Repetitions = *repetitions
+	}
+	if *verbose {
+		suite.Progress = os.Stdout
+	}
+
+	summary, err := evidence.RunSuite(context.Background(), suite)
+	if err != nil {
+		fmt.Fprintln(os.Stderr, "suite execution failed safely")
+		os.Exit(1)
+	}
+	fmt.Printf(
+		"suite completed: %d/%d passed (%.1f%%), median %s\n",
+		summary.PassedRuns,
+		summary.TotalRuns,
+		summary.PassRate*100,
+		summary.MedianDuration,
+	)
+	if summary.PassedRuns != summary.TotalRuns {
+		os.Exit(1)
+	}
+}

From 3a73c322ce93b16ea90a95ffa635eccd140b375b Mon Sep 17 00:00:00 2001
From: Jader Correa <jadercorrea.hv@gmail.com>
Date: Wed, 29 Jul 2026 12:59:57 -0300
Subject: [PATCH 3/3] docs: launch evidence-based AI series

The local-agent study had the depth of an engineering paper but made its central capability-versus-reliability result expensive to discover and difficult to distribute outside the site.

Launch Evidence-Based AI Engineering with an executive summary, accessible experiment figure, stronger conclusion, 1,071-word technical brief, and measured copy for LinkedIn, X, Hacker News, and a five-minute video. Tie every format back to the immutable evidence release and protect the editorial contract with site tests.

The paper remains the canonical technical account and the brief is an entry point, not a replacement. Browser-based page inspection was unavailable in this session, so the generated HTML, responsive markup, full-resolution graphic, Jekyll build, and repository quality gate were verified independently.
---
 README.md                                     |   3 +-
 _roadmap.md                                   |   1 +
 ...026-07-29-capability-is-not-reliability.md | 266 +++++++++++
 docs/_layouts/post.html                       |  52 +++
 ...026-07-29-capability-is-not-reliability.md | 183 ++++++++
 ...cessful-agent-run-proves-almost-nothing.md | 431 ++++++++++++++++++
 docs/assets/agent-reliability-results.png     | Bin 0 -> 100642 bytes
 docs/assets/agent-reliability-results.svg     |  43 ++
 docs/test/site_identity_test.rb               |  68 +++
 9 files changed, 1046 insertions(+), 1 deletion(-)
 create mode 100644 docs/_distribution/2026-07-29-capability-is-not-reliability.md
 create mode 100644 docs/_posts/2026-07-29-capability-is-not-reliability.md
 create mode 100644 docs/_posts/2026-07-29-one-successful-agent-run-proves-almost-nothing.md
 create mode 100644 docs/assets/agent-reliability-results.png
 create mode 100644 docs/assets/agent-reliability-results.svg

diff --git a/README.md b/README.md
index c9586fd..49d506a 100644
--- a/README.md
+++ b/README.md
@@ -15,7 +15,8 @@ code.
 [Website](https://gptcode.dev) ·
 [Architecture](https://gptcode.dev/#architecture) ·
 [Documentation](https://gptcode.dev/guides/getting-started) ·
-[Engineering essay](https://gptcode.dev/blog/the-workflow-is-the-source-of-truth/)
+[Engineering thesis](https://gptcode.dev/blog/the-workflow-is-the-source-of-truth/) ·
+[Evaluation essay](https://gptcode.dev/blog/2026-07-29-one-successful-agent-run-proves-almost-nothing)
 
 <p align="center">
   <a href="https://gptcode.dev">
diff --git a/_roadmap.md b/_roadmap.md
index 258f7a1..e97fd32 100644
--- a/_roadmap.md
+++ b/_roadmap.md
@@ -48,6 +48,7 @@ engineering portfolio.
 - [x] Find a fully GPU-backed local configuration that passes the strengthened safe-store contract, while retaining Qwen's extended-budget failure as negative evidence.
 - [x] Stream verbose agent stages from the evidence suite without sacrificing the replayable output bundle.
 - [x] Measure Devstral safe-store repeatability and retain the 0/3 timeout result alongside the earlier reviewed capability pass.
+- [x] Launch Evidence-Based AI Engineering with a full paper, technical brief, reusable result figure, and evidence-linked distribution package.
 - [ ] Improve local safe-store convergence; neither Qwen nor Devstral currently supports a reliability claim on the strengthened contract.
 - [ ] Extend reviewed repeatability beyond one fixture before publishing a general coding-agent success-rate claim.
 - [ ] Add an OpenCode importer to challenge the vendor-neutral evidence model.
diff --git a/docs/_distribution/2026-07-29-capability-is-not-reliability.md b/docs/_distribution/2026-07-29-capability-is-not-reliability.md
new file mode 100644
index 0000000..e9dfc92
--- /dev/null
+++ b/docs/_distribution/2026-07-29-capability-is-not-reliability.md
@@ -0,0 +1,266 @@
+# Capability Is Not Reliability
+
+Canonical paper:
+https://gptcode.dev/blog/2026-07-29-one-successful-agent-run-proves-almost-nothing
+
+Technical brief:
+https://gptcode.dev/blog/2026-07-29-capability-is-not-reliability
+
+Evidence release:
+https://github.com/jadercorrea/ai-experiments/releases/tag/2026.07.29.1
+
+## LinkedIn
+
+I watched a local coding agent solve a security-sensitive task.
+
+It changed one Go file, preserved the public API, passed the tests under the
+race detector, and passed static analysis. No hosted model was used.
+
+Then I ran the same configuration three more times.
+
+It failed every run.
+
+That experiment reinforced a distinction that is easy to miss when evaluating
+AI systems:
+
+Capability is not reliability.
+
+One successful run proves that a system can produce a result. It tells us very
+little about how often it will produce that result under controlled repetition.
+
+The first campaign demonstrated bounded capability: 1/1 passed in 26 minutes.
+The subsequent repeatability campaign was 0/3, with every run reaching the
+30-minute timeout.
+
+The failed runs were not noise to discard. They exposed different failures at
+the security boundary and defects in the surrounding agent harness: hidden
+progress, mismatched timeouts, wasteful retries, and incorrect final status.
+
+I published the full protocol, patches, command logs, snapshots, verification
+results, limitations, and checksum as an immutable release.
+
+Engineering decisions should depend on repeated, inspectable evidence, not the
+most memorable demonstration.
+
+One successful run demonstrates possibility. Engineering depends on
+repeatability.
+
+Full paper:
+https://gptcode.dev/blog/2026-07-29-one-successful-agent-run-proves-almost-nothing
+
+Raw evidence:
+https://github.com/jadercorrea/ai-experiments/releases/tag/2026.07.29.1
+
+## X thread
+
+1/10
+
+I watched a local coding agent solve a security-sensitive Go task. It preserved
+the public API, passed `go test -race`, passed `go vet`, and used no paid API.
+
+Then I ran the same configuration three more times.
+
+It failed every run.
+
+2/10
+
+The lesson was not that local models are useless.
+
+It was that capability is not reliability.
+
+One successful run proves a system can produce a result. It does not tell us
+how often it will.
+
+3/10
+
+The first campaign was a capability check:
+
+1/1 passed in 26m08s.
+
+The subsequent repeatability campaign:
+
+0/3 passed. Every run timed out at roughly 30 minutes.
+
+These campaigns answer different questions and should not be combined into an
+artificial 1/4 score.
+
+4/10
+
+The task enforced filesystem containment:
+
+- preserve legitimate nested paths;
+- reject traversal and absolute paths;
+- reject a pre-existing symlink escape;
+- preserve the public API;
+- pass the race detector and static analysis.
+
+5/10
+
+An earlier model “passed” by rejecting every filename containing `..`.
+
+That also rejected the legitimate name `v1..v2.txt`.
+
+The agent had not solved traversal. It had prohibited a substring.
+
+Better evaluation made the model look worse and the evidence more truthful.
+
+6/10
+
+The failed runs mattered.
+
+Two rejected legitimate nested paths. Another accepted an absolute path and a
+symlink escape. Some retries regressed cases that had already passed.
+
+Those artifacts explain more than an aggregate score.
+
+7/10
+
+The experiment also found defects in the agent system:
+
+- a provider timeout shorter than the suite budget;
+- progress hidden until completion;
+- retries repeating equivalent failures;
+- final status contradicting successful verification.
+
+8/10
+
+Fixing those defects did not make the model smarter.
+
+It made the system more observable, economical, and honest when the model was
+not capable enough.
+
+9/10
+
+A useful agent evaluation retains the initial state, task, configuration,
+commands, patch, failed runs, verification output, final snapshot, duration,
+and human-review boundary.
+
+The unit of evidence is the restorable run, not the selected transcript.
+
+10/10
+
+I published the complete paper and immutable 2026.07.29.1 evidence release.
+
+One successful run demonstrates possibility.
+
+Engineering depends on repeatability.
+
+https://gptcode.dev/blog/2026-07-29-one-successful-agent-run-proves-almost-nothing
+
+## Hacker News
+
+Suggested title:
+
+One Successful Agent Run Proves Almost Nothing
+
+Submission URL:
+
+https://gptcode.dev/blog/2026-07-29-one-successful-agent-run-proves-almost-nothing
+
+First comment:
+
+Author here. I ran a local coding model against a small but security-sensitive
+filesystem-containment fixture. It passed one capability check, then timed out
+in all three runs of a subsequent repeatability campaign.
+
+The article is about the evaluation method rather than the model: clean
+workspaces, required failing baselines, retained failed patches, deterministic
+verification, final snapshots, human-review boundaries, and why capability and
+reliability are different claims.
+
+The raw evidence is published in the immutable `2026.07.29.1` release:
+https://github.com/jadercorrea/ai-experiments/releases/tag/2026.07.29.1
+
+The main limitation is also documented: the historical runner came from a
+precursor working tree whose exact transient build commit was not retained.
+Future campaigns require a clean immutable harness revision before execution.
+
+I would be especially interested in how others predeclare agent evaluations,
+retain negative runs, and decide when a local model should escalate to a hosted
+one.
+
+## Five-minute video
+
+### 0:00–0:35 — Hook
+
+I watched a local coding agent solve a security-sensitive task. It changed one
+Go file, preserved the public API, passed the Go race detector, and passed
+static analysis.
+
+Then I ran the same configuration three more times. It failed every run.
+
+That is the difference between capability and reliability.
+
+### 0:35–1:15 — The task
+
+The fixture was a small Go file store. Legitimate nested files had to work, but
+absolute paths, parent traversal, and escape through a pre-existing symlink had
+to fail.
+
+It also contained a false-positive guard: `v1..v2.txt` is a legitimate
+filename. An earlier model looked successful only because it rejected every
+name containing two adjacent dots.
+
+The contract had to distinguish a real solution from a plausible shortcut.
+
+### 1:15–2:05 — The result
+
+With Devstral Small 2 running through Ollama at a 16,384-token context, the
+capability check passed in 26 minutes and 8 seconds.
+
+The same configuration then entered a separate repeatability campaign. Three
+fresh workspaces, the same task, the same model profile, the same verification
+commands, and the same 30-minute budget.
+
+All three runs timed out.
+
+Show the result figure here.
+
+The first campaign proved possibility. The second did not support a reliability
+claim.
+
+### 2:05–3:00 — What failures revealed
+
+The failed runs were valuable. Two rejected legitimate nested paths. Another
+accepted an absolute path and a symlink escape. Some retries regressed
+previously passing behavior.
+
+The experiment also exposed defects in the agent harness: an internal timeout
+shorter than the suite budget, no visible progress during long runs, repeated
+equivalent failures, and a final status that could contradict successful
+verification.
+
+Fixing these problems did not improve the model. It improved the truthfulness
+of the system around it.
+
+### 3:00–4:00 — What counts as evidence
+
+For agent evaluation, I now want the initial repository, exact task and
+configuration, clean workspace, command stream, patch, deterministic
+verification, final snapshot, duration, failed runs, and human-review boundary.
+
+Tests establish truth only within the encoded contract. The successful patch
+still retained a possible check-to-write race against an actively hostile
+concurrent process. That limitation belongs in the result.
+
+### 4:00–4:40 — The local inference boundary
+
+Local AI may follow the path of recording tools. Much of the work that once
+required a professional studio can now be done well at home. Studios remain
+important for specialized work, but they are no longer mandatory for every
+recording.
+
+Likewise, frontier models and managed inference will remain essential, but not
+every bounded engineering task should necessarily require them.
+
+The system should try locally, verify deterministically, and escalate structured
+evidence when progress plateaus.
+
+### 4:40–5:00 — Close
+
+The complete experiment, including failed patches and snapshots, is published
+under release `2026.07.29.1`.
+
+One successful run demonstrates possibility.
+
+Engineering depends on repeatability.
diff --git a/docs/_layouts/post.html b/docs/_layouts/post.html
index f400c22..ff8b453 100644
--- a/docs/_layouts/post.html
+++ b/docs/_layouts/post.html
@@ -4,6 +4,11 @@
 
 <article class="post">
   <header class="post-header">
+    {% if page.series %}
+      <p class="post-series">
+        {{ page.series }}{% if page.format %} · {{ page.format }}{% endif %}
+      </p>
+    {% endif %}
     <h1 class="post-title">{{ page.title }}</h1>
     <div class="post-meta">
       <time datetime="{{ page.date | date_to_xmlschema }}">
@@ -41,6 +46,16 @@ <h1 class="post-title">{{ page.title }}</h1>
   margin-bottom: var(--spacing-sm);
 }
 
+.post-series {
+  margin: 0 0 var(--spacing-sm);
+  color: var(--color-primary);
+  font-family: var(--font-mono);
+  font-size: 12px;
+  font-weight: 600;
+  letter-spacing: 0.08em;
+  text-transform: uppercase;
+}
+
 .post-meta {
   color: var(--color-text-muted);
   font-size: 14px;
@@ -58,6 +73,43 @@ <h1 class="post-title">{{ page.title }}</h1>
   display: none; /* Hide duplicate H1 from markdown */
 }
 
+.paper-abstract {
+  display: block;
+  margin: 0 0 var(--spacing-xl);
+  padding: var(--spacing-lg);
+  border-left: 3px solid var(--color-primary);
+  background: var(--color-code-bg);
+  color: var(--color-text-muted);
+  line-height: 1.7;
+}
+
+.paper-abstract strong {
+  display: block;
+  margin-bottom: var(--spacing-xs);
+  color: var(--color-text);
+}
+
+.result-figure {
+  width: min(960px, calc(100vw - 32px));
+  margin: var(--spacing-xl) 0 var(--spacing-xl) 50%;
+  transform: translateX(-50%);
+}
+
+.result-figure img {
+  display: block;
+  width: 100%;
+  height: auto;
+  border: 1px solid var(--color-border);
+  border-radius: 8px;
+}
+
+.result-figure figcaption {
+  margin-top: var(--spacing-sm);
+  color: var(--color-text-muted);
+  font-size: 13px;
+  line-height: 1.5;
+}
+
 .post-footer {
   padding-top: var(--spacing-lg);
   border-top: 1px solid var(--color-border);
diff --git a/docs/_posts/2026-07-29-capability-is-not-reliability.md b/docs/_posts/2026-07-29-capability-is-not-reliability.md
new file mode 100644
index 0000000..870b4d6
--- /dev/null
+++ b/docs/_posts/2026-07-29-capability-is-not-reliability.md
@@ -0,0 +1,183 @@
+---
+layout: post
+title: "Capability Is Not Reliability"
+date: 2026-07-29 09:00:00 -0300
+author: Jader Correa
+series: Evidence-Based AI Engineering
+format: Technical brief
+tags: [ai-agents, software-engineering, evaluation, reliability]
+description: "A concise argument for evaluating coding agents through controlled repetition and executable evidence, not selected demonstrations."
+image: /assets/agent-reliability-results.png
+---
+
+Yesterday I watched a local coding agent solve a security-sensitive task. It
+changed one Go file, preserved the public API, passed the test suite under the
+race detector, and passed static analysis. It used no hosted model and incurred
+no API cost.
+
+Then I ran the same configuration three more times.
+
+Every run timed out.
+
+That sequence captures a distinction we routinely blur when evaluating AI
+systems:
+
+> A successful run demonstrates capability. It does not establish reliability.
+
+The first result answers whether the system *can* produce a valid solution. It
+does not tell us how often the solution will appear, how sensitive the outcome
+is to sampling, or whether the system is safe to use without supervision.
+
+Those questions require controlled repetition and retained evidence.
+
+<figure class="result-figure">
+  <img
+    src="{{ '/assets/agent-reliability-results.svg' | relative_url }}"
+    alt="The capability campaign passed one of one runs. The subsequent repeatability campaign timed out in all three runs."
+    width="1200"
+    height="630"
+  >
+  <figcaption>
+    One bounded capability success followed by a separate 0/3 repeatability
+    campaign. The campaigns answer different questions.
+  </figcaption>
+</figure>
+
+## Why demonstrations are persuasive
+
+A good agent transcript resembles engineering work. The model inspects files,
+forms a plan, edits code, runs tests, reacts to failures, and eventually
+announces completion. When the final diff is correct, the trajectory feels
+like proof.
+
+But it remains one observation.
+
+The visible run may also be the survivor of prompt changes, model selection,
+context tuning, retries, and discarded attempts. The audience sees the coherent
+result. The operator remembers the search process. If failed runs are not
+preserved, neither can measure what the demonstration represents.
+
+This is not unique to AI. Engineering disciplines distinguish a prototype that
+works once from a process that performs consistently. Agent evaluation should
+do the same.
+
+## The experiment
+
+The task was intentionally small but adversarial. A Go package wrote named
+files beneath a configured root. The implementation had to preserve legitimate
+nested paths while rejecting absolute paths, parent traversal, and escape
+through a pre-existing symlink.
+
+The executable contract also protected against a tempting shortcut. A filename
+such as `reports/v1..v2.txt` had to remain valid. An earlier model appeared to
+solve traversal by rejecting every string containing two adjacent dots. Human
+review showed that it had prohibited a substring, not secured the filesystem.
+
+After strengthening the fixture, I ran Devstral Small 2 locally through Ollama.
+At a 16,384-token context, Ollama reported a 17 GB footprint and full GPU
+residency on an Apple M1 Pro.
+
+The capability check passed in 26 minutes and 8 seconds:
+
+```text
+go test -count=1 -race ./...    PASS
+go vet ./...                    PASS
+```
+
+I then ran a separate three-repetition campaign. Every repetition started from
+a fresh workspace, required a failing baseline, used the same model profile,
+context, verification commands, retry limit, and 30-minute budget.
+
+All three timed out.
+
+Two attempts rejected legitimate nested paths. Another accepted an absolute
+path and a symlink escape. The model understood much of the problem and
+produced substantive changes. It did not converge within the declared budget.
+
+The conclusion is neither “local models work” nor “local models are useless.”
+It is narrower and more useful:
+
+> This configuration demonstrated bounded capability. It did not demonstrate
+> repeatable reliability.
+
+## Evidence changes the engineering conversation
+
+A pass rate alone is insufficient. To understand an agent run, I want the
+initial repository, exact task and configuration, clean workspace, command
+stream, produced patch, deterministic verification output, final snapshot,
+duration, exit status, and the failures from unsuccessful repetitions.
+
+Negative artifacts often contain more engineering information than the selected
+success. They reveal whether the model misunderstood the contract, adopted an
+unsafe approximation, entered a tool loop, regressed earlier progress, or
+simply ran out of time near a valid solution.
+
+The experiment also exposed failures in the harness itself. A provider timeout
+was shorter than the suite budget. Long-running output was captured but hidden
+until completion. Equivalent verification failures could consume the remaining
+retry budget. A final successful verification could be reported as failed
+because intermediate errors were treated as authoritative.
+
+Fixing those defects did not make the model more capable. It made the system
+more observable, more economical, and more honest when the model was not
+capable enough.
+
+## Tests define the boundary of the claim
+
+Even the successful run should not be overstated. It passed the declared
+traversal, absolute-path, and pre-existing-symlink cases. Human review found a
+possible check-to-write race if a hostile concurrent process changed the
+filesystem after validation.
+
+The patch satisfied the fixture. It was not a universal race-free filesystem
+primitive.
+
+Executable verification is stronger than accepting the model's assertion, but
+it proves only the properties encoded by the contract. Human review still has
+to decide whether those properties are sufficient for the environment.
+
+## Local inference needs an escalation policy
+
+I expect local AI to follow part of the path that recording technology followed.
+When I began recording music, serious work usually required access to a studio.
+Today, much of that work can be done well at home. Professional studios remain
+valuable for specialized rooms, equipment, expertise, and larger productions.
+What changed is that centralized infrastructure is no longer mandatory for
+every recording.
+
+Frontier models, serverless inference, and managed MLOps will remain important.
+But every repository question and bounded code change should not necessarily
+require the largest hosted model.
+
+The practical problem is identifying the boundary.
+
+A local-first agent should try the lower-cost model, verify the result
+deterministically, and finish when the contract passes. When progress plateaus
+or the budget expires, it should escalate a structured evidence package to a
+more capable model: repository facts, constraints, attempted patches,
+verification failures, and the commands that define success.
+
+That turns the economic question into something measurable: how much hosted
+inference can local execution avoid without reducing the final verified success
+rate?
+
+## What to measure next
+
+One pass does not justify a deployment policy. Neither does one failed batch.
+The next useful evidence comes from predeclared campaigns across multiple
+fixtures, model configurations, and failure classes.
+
+The important unit is not the memorable transcript. It is the repeated,
+restorable, independently inspectable run.
+
+The complete engineering paper,
+[One Successful Agent Run Proves Almost Nothing]({% post_url 2026-07-29-one-successful-agent-run-proves-almost-nothing %}),
+documents the task, fixture corrections, failure modes, harness changes, local
+inference argument, and human-review boundary. The
+[2026.07.29.1 evidence release](https://github.com/jadercorrea/ai-experiments/releases/tag/2026.07.29.1)
+contains the historical patches, command logs, verification results, and
+repository snapshots.
+
+One successful run demonstrates possibility.
+
+Engineering depends on repeatability.
diff --git a/docs/_posts/2026-07-29-one-successful-agent-run-proves-almost-nothing.md b/docs/_posts/2026-07-29-one-successful-agent-run-proves-almost-nothing.md
new file mode 100644
index 0000000..ac1748d
--- /dev/null
+++ b/docs/_posts/2026-07-29-one-successful-agent-run-proves-almost-nothing.md
@@ -0,0 +1,431 @@
+---
+layout: post
+title: "One Successful Agent Run Proves Almost Nothing"
+date: 2026-07-29
+author: Jader Correa
+series: Evidence-Based AI Engineering
+format: Engineering paper
+tags: [ai-agents, software-engineering, evaluation, local-models, verification]
+description: "A local coding model passed a security-sensitive task once and failed the next three clean runs. What the experiment taught me about capability, reliability, and evidence."
+image: /assets/agent-reliability-results.png
+---
+
+<aside class="paper-abstract" aria-label="Executive summary">
+  <strong>In brief: Capability is not reliability.</strong>
+  A local coding model satisfied a security-sensitive contract once in 26
+  minutes. In a subsequent three-run repeatability campaign, the same
+  configuration timed out every time. The first result demonstrates
+  possibility. The later results do not support a reliability claim.
+</aside>
+
+A coding agent completed a security-sensitive task on my machine. It changed
+one Go file, passed the tests under the race detector, passed static analysis,
+and used no paid API.
+
+Then I ran the same experiment three more times.
+
+It failed every run.
+
+This is not an argument that coding agents are useless. It is an argument that
+the unit of evidence matters. A successful demonstration establishes that a
+system can produce a result. It does not establish how often the result can be
+produced, how dependent it is on sampling, or whether the process is suitable
+for unattended engineering work.
+
+The distinction is easy to lose because a good agent run is unusually
+persuasive. We see the model inspect files, edit code, run tests, repair a
+failure, and announce completion. The transcript resembles work. The final
+diff may even be correct.
+
+But one run is still one observation.
+
+<figure class="result-figure">
+  <img
+    src="{{ '/assets/agent-reliability-results.svg' | relative_url }}"
+    alt="The capability campaign passed one of one runs. The subsequent repeatability campaign timed out in all three runs. Capability was demonstrated; reliability was not."
+    width="1200"
+    height="630"
+  >
+  <figcaption>
+    Two sequential campaigns with different purposes: a capability check,
+    followed by a controlled repeatability measurement.
+  </figcaption>
+</figure>
+
+## The task
+
+I was evaluating local execution in
+[GPTCode](https://github.com/jadercorrea/gptcode), an open-source coding CLI
+built around explicit research, planning, implementation, review, and
+verification stages.
+
+The fixture was deliberately small. It contained a Go package with a `Store`
+that writes a named file beneath a configured root:
+
+```go
+type Store struct {
+	root string
+}
+
+func New(root string) *Store {
+	return &Store{root: root}
+}
+
+func (s *Store) Write(name string, content []byte) error {
+	path := filepath.Join(s.root, name)
+	if err := os.MkdirAll(filepath.Dir(path), 0o700); err != nil {
+		return err
+	}
+	return os.WriteFile(path, content, 0o600)
+}
+```
+
+The implementation was vulnerable by construction. A caller could supply an
+absolute path, use parent-directory traversal, or escape through a symlinked
+parent.
+
+The requested change had to satisfy several properties:
+
+- ordinary nested files must still work;
+- dots inside a legitimate filename, such as `v1..v2.txt`, must remain valid;
+- direct and normalized traversal must be rejected;
+- absolute paths must be rejected;
+- a parent directory that is already a symlink must not permit an escape;
+- the public API must remain unchanged;
+- tests must pass under the race detector;
+- `go vet` must pass.
+
+This is a small task in lines of code, but not a trivial one. Filesystem
+containment contains edge cases that plausible-looking prefix checks often
+miss. It was useful precisely because the contract could distinguish a real
+solution from a convenient approximation.
+
+## The contract had already caught a false positive
+
+An earlier version of the fixture appeared to pass with Qwen3-Coder. Human
+review found that the generated implementation rejected every name containing
+`..`, including the legitimate `reports/v1..v2.txt`.
+
+The agent had not solved path traversal. It had prohibited a substring.
+
+The contract was strengthened.
+
+A second weakness appeared on macOS. The temporary root used by the test could
+pass through `/var`, which is itself a symlink. A naive implementation could
+therefore appear to reject the malicious case for the wrong reason. The test
+was changed to resolve the temporary root before constructing the adversarial
+path.
+
+These were not model improvements. They were measurement improvements.
+
+That distinction is important. Better benchmarks often make systems look worse
+before they make them better. A falling score can mean the evaluation has
+stopped rewarding shortcuts.
+
+## The first Devstral run
+
+I tested Devstral Small 2 through Ollama on an Apple M1 Pro with 32 GB of
+unified memory.
+
+The initial configuration used a 65,536-token context. Ollama reported a
+25 GB runtime footprint with eight percent of the model offloaded to CPU. A
+32,768-token context kept the execution fully on the GPU, but the run exhausted
+the 30-minute task budget without converging.
+
+At 16,384 tokens, the model occupied 17 GB and Ollama reported 100 percent GPU
+execution. The repository was tiny, so the smaller context still contained
+the task, source, tests, skills, and retry evidence.
+
+That run completed in 26 minutes and 8 seconds.
+
+The first implementation passed every test except the symlinked-parent case.
+GPTCode returned the exact deterministic failure to the editor. The second
+implementation passed:
+
+```text
+go test -count=1 -race ./...    PASS
+go vet ./...                    PASS
+```
+
+The agent modified one file. The exported API remained unchanged. No paid API
+was called.
+
+This was a legitimate success against the executable contract. It was also an
+attractive demonstration:
+
+```text
+Analyze
+Plan
+Implement
+Verify
+Repair
+Verify
+Pass
+```
+
+It would have been easy to stop there.
+
+## The repeatability run
+
+Instead, I ran the same committed configuration three times.
+
+Each repetition began with:
+
+- a fresh copy of the fixture;
+- a new Git repository and baseline commit;
+- a required failing baseline;
+- the same model profile;
+- the same 16,384-token context;
+- the same 30-minute budget;
+- the same maximum retry count;
+- the same verification commands.
+
+Runs were sequential so local resource contention would not bias the
+comparison. Ollama continued to report 100 percent GPU execution.
+
+The result was:
+
+| Repetition | Result | Duration | Final observed failure |
+| --- | ---: | ---: | --- |
+| 1 | timed out | 30m01s | legitimate nested paths rejected |
+| 2 | timed out | 30m01s | legitimate nested paths rejected |
+| 3 | timed out | 30m01s | absolute path and symlink escape accepted |
+
+Pass rate: **0/3**.
+
+Median duration: **30m01s**.
+
+The model did not ignore the task. It produced relevant plans and several
+substantive implementations. It recognized traversal, absolute paths, and
+symlinks. Some attempts came close.
+
+It did not converge within the agreed budget.
+
+In two runs, it tried to validate symlinks by calling `lstat` or
+`EvalSymlinks` on a path that did not yet exist. This rejected legitimate
+nested writes. In another, it implemented lexical containment but failed to
+reject an absolute input and a symlinked parent. Some retries regressed a case
+that had passed in the previous attempt. One editor cycle consumed twenty tool
+calls without producing a diff.
+
+These are not cosmetic variations. They are different failure modes at the
+security boundary.
+
+## Capability is not reliability
+
+The first run and the next three runs are not contradictory.
+
+Together they support a more precise conclusion:
+
+> The configuration demonstrated the capability to solve the bounded task,
+> but did not demonstrate the reliability required to solve it repeatedly.
+
+Capability asks whether a result is possible.
+
+Reliability asks how often the result is produced under controlled repetition.
+
+An impressive demo usually answers the first question. Engineering decisions
+usually require the second.
+
+This is especially important for agentic systems because the visible run is
+often selected after development, prompt adjustment, model selection, and
+several discarded attempts. The viewer sees a coherent trajectory. The system
+owner remembers the search process. Unless failures are retained, neither can
+calculate what the demonstration represents.
+
+## The agent did not fail alone
+
+The experiment also found defects in the surrounding system.
+
+The first Devstral attempt never reached an edit because GPTCode's Ollama
+client had a fixed 120-second request timeout. The suite allowed 30 minutes,
+but an internal client layer silently imposed a much smaller budget. The
+provider now has a longer local default and explicit controls for request
+timeout and context length.
+
+The evidence suite originally captured stdout and stderr but displayed them
+only after completion. A 20-minute local run therefore looked indistinguishable
+from a hung process. It now supports verbose streaming while preserving the
+same output in the evidence bundle.
+
+The retry loop could also spend its remaining budget repeating an equivalent
+test failure. GPTCode now detects a verification plateau and stops after three
+equivalent failures. Timing noise and Go temporary-directory identifiers are
+normalized so ephemeral output does not masquerade as progress.
+
+Finally, the execution summary once reported `STATUS: FAILED` when the final
+verification had passed, because it treated recoverable intermediate errors
+as the authoritative outcome. Intermediate errors are still retained, but the
+final status now reflects the verified result.
+
+None of these changes made the model more intelligent.
+
+They made the system more truthful, observable, and economical when the model
+was not intelligent enough.
+
+## What should count as evidence
+
+For a coding-agent experiment, I now want at least the following:
+
+1. The initial repository state, including the baseline used by the agent.
+2. The exact task and model configuration.
+3. A clean workspace for every repetition.
+4. The agent's stdout, stderr, exit code, and duration.
+5. The patch produced by the agent, including failed runs.
+6. Deterministic verification commands and their outputs.
+7. A final repository snapshot that can be restored independently.
+8. Human review of what the executable contract does not prove.
+9. Repetition before making a reliability claim.
+
+GPTCode's evaluation harness now records these as replayable evidence bundles.
+A successful agent exit is insufficient. Every required verification command
+must also pass.
+
+The inverse matters too: a failed run must not disappear. Failed patches show
+whether the model misunderstood the problem, chose an unsafe approximation,
+entered a tool loop, or simply ran out of time near a valid solution.
+
+Aggregate scores without failed artifacts conceal most of the engineering
+information.
+
+## Tests establish a boundary, not universal correctness
+
+Even the successful run should not be overstated.
+
+The generated implementation passed the fixture's traversal, absolute-path,
+and pre-existing-symlink cases. Human review found that its symlink check and
+file write were separate operations. A concurrently hostile process could
+potentially change the filesystem between the check and the write.
+
+The patch satisfied the declared fixture. It was not a race-free filesystem
+primitive suitable for an active adversary.
+
+This is not a reason to dismiss tests. It is a reason to state their boundary.
+Executable verification is stronger than the model's assertion, but it proves
+the encoded contract, not every property a future environment may require.
+
+Repositories define constraints. Verification establishes truth only within
+those constraints. Engineering review still decides whether the constraints
+are sufficient.
+
+## From recording studios to local inference
+
+My interest in local models did not begin with a model benchmark. It came from
+an older change I watched happen in music.
+
+When I started recording, going to a studio was not merely a preference. The
+equipment, room, engineering knowledge, and production infrastructure were
+there. If I wanted a serious result, I had to go where those resources were.
+
+Today I record at home. For most of what I need, the tools have become good
+enough that hiring a studio is no longer the default. This did not make
+professional studios obsolete. A purpose-built room, an experienced engineer,
+specialized equipment, and the ability to coordinate a large production still
+matter. What changed was the boundary between work that required centralized
+infrastructure and work that could be done well on a personal machine.
+
+Voice production and radio went through related changes. Work that once
+depended on access to a particular facility can now be produced, edited, and
+distributed from a much smaller setup. Large studios and broadcast
+infrastructure remain valuable, but they are no longer mandatory for every
+recording.
+
+I suspect part of the AI market will move in the same direction.
+
+Frontier-model providers, serverless inference, and managed MLOps will continue
+to be necessary. They concentrate hardware, operational expertise, model
+access, and reliability that most individuals and companies should not
+recreate. But that does not mean every repository question, code review, or
+bounded change will always need to be sent to Claude, Codex, or another hosted
+system.
+
+This experiment was an attempt to locate that boundary.
+
+In a separate temporal and concurrency fixture, Qwen3-Coder completed three
+clean runs with a median of 4 minutes and 7 seconds. Each run passed the race
+detector and static analysis. The filesystem experiment produced a different
+answer: Devstral demonstrated that it could solve the contract once, then
+failed three controlled repetitions.
+
+That is more useful than a general claim that local models are either ready or
+useless. Some work has already moved into the home studio. Some work still
+needs the larger room.
+
+The engineering problem is to tell the difference before wasting time or
+accepting an unreliable result.
+
+## The next system should escalate evidence
+
+When a local model stops making progress, the system should not merely restart
+the task with a larger model and discard everything learned.
+
+It should escalate an evidence package:
+
+- repository facts already inspected;
+- the approved constraints;
+- patches attempted;
+- verification failures;
+- plateau or timeout reason;
+- commands required to establish success.
+
+The more capable model should inherit the failed work as structured evidence,
+not as an unbounded transcript. If it succeeds, the same deterministic gates
+should judge the result.
+
+This creates a useful local-first policy:
+
+```text
+Try locally
+    ↓
+Verify deterministically
+    ↓
+Pass → finish
+    ↓
+Plateau or timeout → escalate evidence
+```
+
+The economic question then becomes measurable: how much hosted-model cost can
+local execution avoid without reducing the final verified success rate?
+
+That is a better product question than whether one model can solve one issue
+in one recording.
+
+## What the failed repetitions proved
+
+The 0/3 result was disappointing if the goal was to publish a successful local
+agent benchmark.
+
+It was valuable if the goal was to understand the system.
+
+It showed that:
+
+- one pass established capability but overstated reliability;
+- the security-sensitive failure class remained unstable;
+- longer time did not guarantee convergence;
+- context size affected GPU residency and behavior;
+- verbose stages were necessary to distinguish work from a hang;
+- retry budgets needed a semantic plateau condition;
+- negative artifacts contained more diagnostic value than a pass rate alone.
+
+The first successful run is still real.
+
+So are the next three failures.
+
+A useful engineering account must be able to hold both facts at once.
+
+The versioned
+[fixture](https://github.com/jadercorrea/gptcode/tree/main/benchmarks/fixtures/go-safe-store),
+[Devstral suite configuration](https://github.com/jadercorrea/gptcode/blob/main/benchmarks/suites/local-devstral-small-2-safe-store.json),
+and
+[result notes](https://github.com/jadercorrea/gptcode/blob/main/benchmarks/results/2026-07-29-local-filesystem.md)
+are available in the GPTCode repository. The
+[versioned experiment record](https://github.com/jadercorrea/ai-experiments/tree/2026.07.29.1/experiments/coding-agents/filesystem-containment/2026-07-29)
+documents the protocol and limitations. Its
+[release](https://github.com/jadercorrea/ai-experiments/releases/tag/2026.07.29.1)
+publishes the historical run bundles, command logs, patches, verification
+results, and repository snapshots under the SHA-256 checksum
+`6ba0bc9bac3eac5ea9e740bb2e268923aa752f7e186902d5eb443d3a1df5054f`.
+
+> One successful run demonstrates possibility.
+>
+> Engineering depends on repeatability.
diff --git a/docs/assets/agent-reliability-results.png b/docs/assets/agent-reliability-results.png
new file mode 100644
index 0000000000000000000000000000000000000000..2b6a29a1b10f1ea82f5e83f3d61a1dbd40907114
GIT binary patch
literal 100642
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

literal 0
HcmV?d00001

diff --git a/docs/assets/agent-reliability-results.svg b/docs/assets/agent-reliability-results.svg
new file mode 100644
index 0000000..4f290b1
--- /dev/null
+++ b/docs/assets/agent-reliability-results.svg
@@ -0,0 +1,43 @@
+<svg xmlns="http://www.w3.org/2000/svg" width="1200" height="630" viewBox="0 0 1200 630" role="img" aria-labelledby="title description">
+  <title id="title">Capability is not reliability</title>
+  <desc id="description">One capability check passed. Three subsequent repeatability runs timed out. Capability was demonstrated; reliability was not.</desc>
+  <rect width="1200" height="630" fill="#0f111a"/>
+  <rect x="48" y="48" width="1104" height="534" rx="18" fill="#161925" stroke="#2a2f42" stroke-width="2"/>
+
+  <text x="88" y="116" fill="#7aa2f7" font-family="ui-monospace, SFMono-Regular, Menlo, monospace" font-size="20" font-weight="700" letter-spacing="2">EVIDENCE-BASED AI ENGINEERING</text>
+  <text x="88" y="176" fill="#c0caf5" font-family="Inter, ui-sans-serif, system-ui, sans-serif" font-size="48" font-weight="700">Capability is not reliability.</text>
+  <text x="88" y="218" fill="#9aa5ce" font-family="Inter, ui-sans-serif, system-ui, sans-serif" font-size="22">Capability campaign followed by repeatability campaign.</text>
+
+  <text x="88" y="286" fill="#9aa5ce" font-family="ui-monospace, SFMono-Regular, Menlo, monospace" font-size="14" letter-spacing="0.5">CAPABILITY CHECK</text>
+  <rect x="88" y="308" width="238" height="106" rx="10" fill="#182b2a" stroke="#73daca" stroke-width="2"/>
+  <circle cx="122" cy="342" r="10" fill="#73daca"/>
+  <text x="148" y="351" fill="#c0caf5" font-family="Inter, ui-sans-serif, system-ui, sans-serif" font-size="28" font-weight="700">PASS</text>
+  <text x="122" y="390" fill="#9aa5ce" font-family="ui-monospace, SFMono-Regular, Menlo, monospace" font-size="18">1 / 1 · 26m08s</text>
+
+  <text x="410" y="286" fill="#9aa5ce" font-family="ui-monospace, SFMono-Regular, Menlo, monospace" font-size="14" letter-spacing="0.5">SUBSEQUENT REPEATABILITY CAMPAIGN</text>
+  <g font-family="Inter, ui-sans-serif, system-ui, sans-serif">
+    <rect x="374" y="308" width="218" height="106" rx="10" fill="#30232a" stroke="#f7768e" stroke-width="2"/>
+    <circle cx="408" cy="342" r="10" fill="#f7768e"/>
+    <text x="434" y="351" fill="#c0caf5" font-size="25" font-weight="700">TIMEOUT</text>
+    <text x="408" y="390" fill="#9aa5ce" font-family="ui-monospace, SFMono-Regular, Menlo, monospace" font-size="18">RUN 1 · 30m01s</text>
+
+    <rect x="614" y="308" width="218" height="106" rx="10" fill="#30232a" stroke="#f7768e" stroke-width="2"/>
+    <circle cx="648" cy="342" r="10" fill="#f7768e"/>
+    <text x="674" y="351" fill="#c0caf5" font-size="25" font-weight="700">TIMEOUT</text>
+    <text x="648" y="390" fill="#9aa5ce" font-family="ui-monospace, SFMono-Regular, Menlo, monospace" font-size="18">RUN 2 · 30m01s</text>
+
+    <rect x="854" y="308" width="218" height="106" rx="10" fill="#30232a" stroke="#f7768e" stroke-width="2"/>
+    <circle cx="888" cy="342" r="10" fill="#f7768e"/>
+    <text x="914" y="351" fill="#c0caf5" font-size="25" font-weight="700">TIMEOUT</text>
+    <text x="888" y="390" fill="#9aa5ce" font-family="ui-monospace, SFMono-Regular, Menlo, monospace" font-size="18">RUN 3 · 30m01s</text>
+  </g>
+
+  <line x1="88" y1="464" x2="1072" y2="464" stroke="#2a2f42" stroke-width="2"/>
+  <text x="88" y="504" fill="#73daca" font-family="Inter, ui-sans-serif, system-ui, sans-serif" font-size="18" font-weight="700">CAPABILITY</text>
+  <text x="88" y="541" fill="#c0caf5" font-family="ui-monospace, SFMono-Regular, Menlo, monospace" font-size="29" font-weight="700">1 / 1</text>
+  <text x="210" y="541" fill="#73daca" font-family="Inter, ui-sans-serif, system-ui, sans-serif" font-size="20" font-weight="700">demonstrated</text>
+  <text x="560" y="504" fill="#f7768e" font-family="Inter, ui-sans-serif, system-ui, sans-serif" font-size="18" font-weight="700">REPEATABILITY</text>
+  <text x="560" y="541" fill="#c0caf5" font-family="ui-monospace, SFMono-Regular, Menlo, monospace" font-size="29" font-weight="700">0 / 3</text>
+  <text x="682" y="541" fill="#f7768e" font-family="Inter, ui-sans-serif, system-ui, sans-serif" font-size="20" font-weight="700">not demonstrated</text>
+  <text x="88" y="570" fill="#7982a9" font-family="ui-monospace, SFMono-Regular, Menlo, monospace" font-size="13">FULL PROTOCOL AND RAW EVIDENCE · AI-EXPERIMENTS 2026.07.29.1</text>
+</svg>
diff --git a/docs/test/site_identity_test.rb b/docs/test/site_identity_test.rb
index 5624ae8..55170cc 100644
--- a/docs/test/site_identity_test.rb
+++ b/docs/test/site_identity_test.rb
@@ -198,4 +198,72 @@ def test_repository_boundary_case_study_is_reproducible
     assert_includes content, "time-of-check/time-of-use"
     assert_includes content, "Verification establishes truth."
   end
+
+  def test_local_agent_paper_leads_with_evidence_and_closes_with_thesis
+    article = File.join(
+      DOCS_ROOT,
+      "_posts",
+      "2026-07-29-one-successful-agent-run-proves-almost-nothing.md"
+    )
+    content = File.read(article)
+
+    assert_includes content, "series: Evidence-Based AI Engineering"
+    assert_includes content, 'format: Engineering paper'
+    assert_includes content, '<aside class="paper-abstract"'
+    assert_includes content, "Capability is not reliability."
+    assert_includes content, '<figure class="result-figure"'
+    assert_includes content, "/assets/agent-reliability-results.svg"
+    assert_includes content, "One successful run demonstrates possibility."
+    assert_includes content, "Engineering depends on repeatability."
+    assert_path_exists File.join(
+      DOCS_ROOT,
+      "assets",
+      "agent-reliability-results.svg"
+    )
+    assert_path_exists File.join(
+      DOCS_ROOT,
+      "assets",
+      "agent-reliability-results.png"
+    )
+  end
+
+  def test_capability_reliability_brief_is_a_distribution_entry_point
+    article = File.join(
+      DOCS_ROOT,
+      "_posts",
+      "2026-07-29-capability-is-not-reliability.md"
+    )
+
+    assert_path_exists article
+    content = File.read(article)
+    body = content.sub(/\A---.*?---/m, "")
+    word_count = body.scan(/\b[\w'-]+\b/).size
+
+    assert_operator word_count, :>=, 1_000
+    assert_operator word_count, :<=, 1_500
+    assert_includes content, "series: Evidence-Based AI Engineering"
+    assert_includes content, 'format: Technical brief'
+    assert_includes content, "One Successful Agent Run Proves Almost Nothing"
+    assert_includes content, "ai-experiments/releases/tag/2026.07.29.1"
+  end
+
+  def test_distribution_copy_is_derived_from_the_published_experiment
+    distribution = File.join(
+      DOCS_ROOT,
+      "_distribution",
+      "2026-07-29-capability-is-not-reliability.md"
+    )
+
+    assert_path_exists distribution
+    content = File.read(distribution)
+
+    assert_includes content, "## LinkedIn"
+    assert_includes content, "## X thread"
+    assert_includes content, "## Hacker News"
+    assert_includes content, "## Five-minute video"
+    assert_includes content, "1/1"
+    assert_includes content, "0/3"
+    assert_includes content, "2026.07.29.1"
+    refute_match(/[\u{1F300}-\u{1FAFF}]/, content)
+  end
 end