feat: add Result type with JSON schema and validation

internal/exec/result.go

@@ -0,0 +1,56 @@
+package exec
+
+import (
+	"errors"
+	"strings"
+)
+
+// Result is the structured JSON output from every supervisor invocation.
+// The JSON schema constant is passed to claude via --json-schema so Claude
+// validates its own output before returning.
+type Result struct {
+	Status       string `json:"status"`        // pass | fail | error
+	Phase        string `json:"phase"`         // red | green | refactor
+	Skill        string `json:"skill"`         // tdd | review | ...
+	FilePath     string `json:"file_path"`     // absolute path to generated file
+	RunnerOutput string `json:"runner_output"` // raw stdout+stderr from test runner
+	Verified     bool   `json:"verified"`      // based on exit code, never self-report
+	ModelUsed    string `json:"model_used"`    // model name or "self"
+	Message      string `json:"message"`       // one sentence summary
+}
+
+var validStatuses = map[string]bool{"pass": true, "fail": true, "error": true}
+var validPhases = map[string]bool{"red": true, "green": true, "refactor": true}
+
+func (r Result) Validate() error {
+	var errs []string
+	if !validStatuses[r.Status] {
+		errs = append(errs, "status must be pass|fail|error, got: "+r.Status)
+	}
+	if !validPhases[r.Phase] {
+		errs = append(errs, "phase must be red|green|refactor, got: "+r.Phase)
+	}
+	if r.Skill == "" {
+		errs = append(errs, "skill is required")
+	}
+	if len(errs) > 0 {
+		return errors.New(strings.Join(errs, "; "))
+	}
+	return nil
+}
+
+// Schema is passed to claude --json-schema to enforce structured output.
+const Schema = `{
+  "type": "object",
+  "required": ["status","phase","skill","file_path","runner_output","verified","model_used","message"],
+  "properties": {
+    "status":        {"type": "string", "enum": ["pass","fail","error"]},
+    "phase":         {"type": "string", "enum": ["red","green","refactor"]},
+    "skill":         {"type": "string"},
+    "file_path":     {"type": "string"},
+    "runner_output": {"type": "string"},
+    "verified":      {"type": "boolean"},
+    "model_used":    {"type": "string"},
+    "message":       {"type": "string"}
+  }
+}`

internal/exec/result_test.go

@@ -0,0 +1,71 @@
+package exec_test
+
+import (
+	"encoding/json"
+	"testing"
+
+	"github.com/mathiasbq/supervisor/internal/exec"
+	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
+)
+
+func TestResultParsesValidJSON(t *testing.T) {
+	raw := `{
+		"status": "pass",
+		"phase": "red",
+		"skill": "tdd",
+		"file_path": "/tmp/foo_test.go",
+		"runner_output": "--- FAIL: TestFoo",
+		"verified": true,
+		"model_used": "self",
+		"message": "test fails as expected"
+	}`
+	var r exec.Result
+	require.NoError(t, json.Unmarshal([]byte(raw), &r))
+	assert.Equal(t, "pass", r.Status)
+	assert.Equal(t, "red", r.Phase)
+	assert.True(t, r.Verified)
+}
+
+func TestResultValidation(t *testing.T) {
+	tests := []struct {
+		name    string
+		result  exec.Result
+		wantErr bool
+	}{
+		{
+			name: "valid pass result",
+			result: exec.Result{
+				Status: "pass", Phase: "red", Skill: "tdd",
+				FilePath: "/tmp/x_test.go", RunnerOutput: "FAIL",
+				Verified: true, ModelUsed: "self", Message: "ok",
+			},
+			wantErr: false,
+		},
+		{
+			name:    "empty status",
+			result:  exec.Result{Phase: "red", Skill: "tdd"},
+			wantErr: true,
+		},
+		{
+			name:    "invalid status",
+			result:  exec.Result{Status: "unknown", Phase: "red", Skill: "tdd"},
+			wantErr: true,
+		},
+		{
+			name:    "invalid phase",
+			result:  exec.Result{Status: "pass", Phase: "bad", Skill: "tdd"},
+			wantErr: true,
+		},
+	}
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			err := tt.result.Validate()
+			if tt.wantErr {
+				assert.Error(t, err)
+			} else {
+				assert.NoError(t, err)
+			}
+		})
+	}
+}