tatara-operator M4 (Task reconciler + agent turn loop) Implementation Plan¶

func TestTurnDurationAndInflight(t *testing.T) {
    reg := prometheus.NewRegistry()
    m := NewOperatorMetrics(reg)

    m.ObserveTurnDuration(1.5)
    m.ObserveTurnDuration(2.5)
    m.SetTasksInflight(3)

    // histogram: assert sample count == 2 via the registry gather.
    mfs, err := reg.Gather()
    require.NoError(t, err)
    var turnCount uint64
    var inflight float64
    for _, mf := range mfs {
        switch mf.GetName() {
        case "operator_turn_duration_seconds":
            for _, mm := range mf.GetMetric() {
                turnCount += mm.GetHistogram().GetSampleCount()
            }
        case "operator_tasks_inflight":
            for _, mm := range mf.GetMetric() {
                inflight = mm.GetGauge().GetValue()
            }
        }
    }
    require.Equal(t, uint64(2), turnCount)
    require.Equal(t, float64(3), inflight)
}

    turnDuration  prometheus.Histogram
    tasksInflight prometheus.Gauge

    m.turnDuration = prometheus.NewHistogram(prometheus.HistogramOpts{
        Name:    "operator_turn_duration_seconds",
        Help:    "Wrapper agent turn durations in seconds.",
        Buckets: prometheus.ExponentialBuckets(1, 2, 12),
    })
    m.tasksInflight = prometheus.NewGauge(prometheus.GaugeOpts{
        Name: "operator_tasks_inflight",
        Help: "Number of Tasks with a running wrapper session.",
    })

// ObserveTurnDuration records a completed wrapper turn duration in seconds.
func (m *OperatorMetrics) ObserveTurnDuration(seconds float64) {
    m.turnDuration.Observe(seconds)
}

// SetTasksInflight sets the gauge of Tasks with a running wrapper session.
func (m *OperatorMetrics) SetTasksInflight(n float64) {
    m.tasksInflight.Set(n)
}

package agent_test

import (
    "errors"
    "testing"

    "github.com/stretchr/testify/require"

    "github.com/szymonrychu/tatara-operator/internal/agent"
)

func TestHTTPError_CarriesStatus(t *testing.T) {
    err := &agent.HTTPError{Status: 409, Body: "turn in flight"}
    require.Contains(t, err.Error(), "409")

    var he *agent.HTTPError
    require.True(t, errors.As(error(err), &he))
    require.Equal(t, 409, he.Status)
}

// Compile-time assertion that *httpSession satisfies Session is in session.go;
// here we only assert the interface and TurnResult shape are present.
func TestTurnResult_Fields(t *testing.T) {
    tr := agent.TurnResult{State: "completed", FinalText: "done", StopReason: "end_turn", Err: ""}
    require.Equal(t, "completed", tr.State)
    require.Equal(t, "done", tr.FinalText)
    require.Equal(t, "end_turn", tr.StopReason)
}

// Package agent talks to the tatara-claude-code-wrapper REST API and builds
// the wrapper Pod + Service that runs a single Claude session per Task.
package agent

import (
    "context"
    "fmt"
)

// TurnResult is the outcome of one wrapper turn, as reported by the wrapper's
// GET /v1/messages/{turnId} response and the turn-complete callback.
type TurnResult struct {
    State, FinalText, StopReason, Err string
}

// Session is the operator's view of one wrapper session. baseURL is the
// per-pod wrapper address (http://<svc>.<ns>.svc:8080).
type Session interface {
    SubmitTurn(ctx context.Context, baseURL, text, callbackURL string) (turnID string, err error)
    GetTurn(ctx context.Context, baseURL, turnID string) (TurnResult, error)
    DeleteSession(ctx context.Context, baseURL string) error
}

// HTTPError is returned when the wrapper responds with a non-2xx status.
type HTTPError struct {
    Status int
    Body   string
}

func (e *HTTPError) Error() string {
    return fmt.Sprintf("wrapper http %d: %s", e.Status, e.Body)
}

package agent_test

import (
    "context"
    "encoding/json"
    "net/http"
    "net/http/httptest"
    "testing"

    "github.com/stretchr/testify/require"

    "github.com/szymonrychu/tatara-operator/internal/agent"
)

func staticToken(_ context.Context) (string, error) { return "test-bearer", nil }

func newSession(t *testing.T, h http.HandlerFunc) (agent.Session, *httptest.Server) {
    t.Helper()
    srv := httptest.NewServer(h)
    t.Cleanup(srv.Close)
    return agent.NewHTTPSession(staticToken), srv
}

func TestSubmitTurn_202(t *testing.T) {
    s, srv := newSession(t, func(w http.ResponseWriter, r *http.Request) {
        require.Equal(t, http.MethodPost, r.Method)
        require.Equal(t, "/v1/messages", r.URL.Path)
        require.Equal(t, "Bearer test-bearer", r.Header.Get("Authorization"))

        var in struct {
            Text        string `json:"text"`
            CallbackURL string `json:"callbackUrl"`
        }
        require.NoError(t, json.NewDecoder(r.Body).Decode(&in))
        require.Equal(t, "do the thing", in.Text)
        require.Equal(t, "http://op/internal/turn-complete", in.CallbackURL)

        w.WriteHeader(http.StatusAccepted)
        _ = json.NewEncoder(w).Encode(map[string]string{"turnId": "turn-1"})
    })

    id, err := s.SubmitTurn(context.Background(), srv.URL, "do the thing", "http://op/internal/turn-complete")
    require.NoError(t, err)
    require.Equal(t, "turn-1", id)
}

func TestSubmitTurn_409(t *testing.T) {
    s, srv := newSession(t, func(w http.ResponseWriter, _ *http.Request) {
        w.WriteHeader(http.StatusConflict)
        _, _ = w.Write([]byte("turn in flight"))
    })
    _, err := s.SubmitTurn(context.Background(), srv.URL, "x", "y")
    require.Error(t, err)
    var he *agent.HTTPError
    require.ErrorAs(t, err, &he)
    require.Equal(t, 409, he.Status)
}

func TestGetTurn(t *testing.T) {
    s, srv := newSession(t, func(w http.ResponseWriter, r *http.Request) {
        require.Equal(t, http.MethodGet, r.Method)
        require.Equal(t, "/v1/messages/turn-9", r.URL.Path)
        _ = json.NewEncoder(w).Encode(map[string]any{
            "state":      "completed",
            "finalText":  "all green",
            "stopReason": "end_turn",
        })
    })
    tr, err := s.GetTurn(context.Background(), srv.URL, "turn-9")
    require.NoError(t, err)
    require.Equal(t, "completed", tr.State)
    require.Equal(t, "all green", tr.FinalText)
    require.Equal(t, "end_turn", tr.StopReason)
    require.Empty(t, tr.Err)
}

func TestGetTurn_CarriesErrorField(t *testing.T) {
    s, srv := newSession(t, func(w http.ResponseWriter, _ *http.Request) {
        _ = json.NewEncoder(w).Encode(map[string]any{
            "state": "failed",
            "error": "boom",
        })
    })
    tr, err := s.GetTurn(context.Background(), srv.URL, "turn-x")
    require.NoError(t, err)
    require.Equal(t, "failed", tr.State)
    require.Equal(t, "boom", tr.Err)
}

func TestGetTurn_NotFound(t *testing.T) {
    s, srv := newSession(t, func(w http.ResponseWriter, _ *http.Request) {
        w.WriteHeader(http.StatusNotFound)
    })
    _, err := s.GetTurn(context.Background(), srv.URL, "missing")
    var he *agent.HTTPError
    require.ErrorAs(t, err, &he)
    require.Equal(t, 404, he.Status)
}

func TestDeleteSession(t *testing.T) {
    called := false
    s, srv := newSession(t, func(w http.ResponseWriter, r *http.Request) {
        require.Equal(t, http.MethodDelete, r.Method)
        require.Equal(t, "/v1/session", r.URL.Path)
        require.Equal(t, "Bearer test-bearer", r.Header.Get("Authorization"))
        called = true
        w.WriteHeader(http.StatusNoContent)
    })
    require.NoError(t, s.DeleteSession(context.Background(), srv.URL))
    require.True(t, called)
}

func TestDeleteSession_PropagatesError(t *testing.T) {
    s, srv := newSession(t, func(w http.ResponseWriter, _ *http.Request) {
        w.WriteHeader(http.StatusInternalServerError)
        _, _ = w.Write([]byte("kaboom"))
    })
    err := s.DeleteSession(context.Background(), srv.URL)
    var he *agent.HTTPError
    require.ErrorAs(t, err, &he)
    require.Equal(t, 500, he.Status)
}

package agent

import (
    "bytes"
    "context"
    "encoding/json"
    "fmt"
    "io"
    "net/http"
    "time"
)

// TokenFunc mints a bearer token for the wrapper audience.
type TokenFunc func(ctx context.Context) (string, error)

// httpSession is the production Session, talking to a wrapper pod's REST API.
type httpSession struct {
    token TokenFunc
    hc    *http.Client
}

// NewHTTPSession returns a Session that authenticates wrapper calls with a
// bearer minted by token (audience tatara-claude-code-wrapper).
func NewHTTPSession(token TokenFunc) Session {
    return &httpSession{token: token, hc: &http.Client{Timeout: 30 * time.Second}}
}

func (s *httpSession) do(ctx context.Context, method, url string, body any, out any) error {
    var rdr io.Reader
    if body != nil {
        b, err := json.Marshal(body)
        if err != nil {
            return fmt.Errorf("agent: marshal body: %w", err)
        }
        rdr = bytes.NewReader(b)
    }
    req, err := http.NewRequestWithContext(ctx, method, url, rdr)
    if err != nil {
        return fmt.Errorf("agent: new request: %w", err)
    }
    tok, err := s.token(ctx)
    if err != nil {
        return fmt.Errorf("agent: mint token: %w", err)
    }
    req.Header.Set("Authorization", "Bearer "+tok)
    req.Header.Set("Accept", "application/json")
    if body != nil {
        req.Header.Set("Content-Type", "application/json")
    }
    resp, err := s.hc.Do(req)
    if err != nil {
        return fmt.Errorf("agent: do request: %w", err)
    }
    defer func() { _ = resp.Body.Close() }()
    if resp.StatusCode < 200 || resp.StatusCode >= 300 {
        b, _ := io.ReadAll(resp.Body)
        return &HTTPError{Status: resp.StatusCode, Body: string(b)}
    }
    if out != nil && resp.StatusCode != http.StatusNoContent {
        if err := json.NewDecoder(resp.Body).Decode(out); err != nil {
            return fmt.Errorf("agent: decode response: %w", err)
        }
    }
    return nil
}

func (s *httpSession) SubmitTurn(ctx context.Context, baseURL, text, callbackURL string) (string, error) {
    body := map[string]string{"text": text, "callbackUrl": callbackURL}
    var out struct {
        TurnID string `json:"turnId"`
    }
    if err := s.do(ctx, http.MethodPost, baseURL+"/v1/messages", body, &out); err != nil {
        return "", err
    }
    return out.TurnID, nil
}

func (s *httpSession) GetTurn(ctx context.Context, baseURL, turnID string) (TurnResult, error) {
    var out struct {
        State      string `json:"state"`
        FinalText  string `json:"finalText"`
        StopReason string `json:"stopReason"`
        Error      string `json:"error"`
    }
    if err := s.do(ctx, http.MethodGet, baseURL+"/v1/messages/"+turnID, nil, &out); err != nil {
        return TurnResult{}, err
    }
    return TurnResult{State: out.State, FinalText: out.FinalText, StopReason: out.StopReason, Err: out.Error}, nil
}

func (s *httpSession) DeleteSession(ctx context.Context, baseURL string) error {
    return s.do(ctx, http.MethodDelete, baseURL+"/v1/session", nil, nil)
}

var _ Session = (*httpSession)(nil)

package agent_test

import (
    "testing"

    "github.com/stretchr/testify/require"
    corev1 "k8s.io/api/core/v1"
    metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"

    tatarav1alpha1 "github.com/szymonrychu/tatara-operator/api/v1alpha1"
    "github.com/szymonrychu/tatara-operator/internal/agent"
)

func sampleInputs() (*tatarav1alpha1.Project, *tatarav1alpha1.Repository, *tatarav1alpha1.Task, agent.PodConfig) {
    proj := &tatarav1alpha1.Project{
        ObjectMeta: metav1.ObjectMeta{Name: "demo", Namespace: "tatara"},
        Spec: tatarav1alpha1.ProjectSpec{
            ScmSecretRef: "demo-scm",
            Agent: tatarav1alpha1.AgentSpec{
                Model: "claude-x", Image: "wrapper:1",
                PermissionMode: "bypassPermissions", TurnTimeoutSeconds: 1800,
            },
        },
    }
    repo := &tatarav1alpha1.Repository{
        ObjectMeta: metav1.ObjectMeta{Name: "repo1", Namespace: "tatara"},
        Spec:       tatarav1alpha1.RepositorySpec{URL: "https://git/acme/repo1", DefaultBranch: "main"},
    }
    task := &tatarav1alpha1.Task{
        ObjectMeta: metav1.ObjectMeta{Name: "task-7", Namespace: "tatara", UID: "uid-task-7"},
        Spec:       tatarav1alpha1.TaskSpec{ProjectRef: "demo", RepositoryRef: "repo1", Goal: "g"},
    }
    cfg := agent.PodConfig{
        Namespace:           "tatara",
        InternalAddr:        "http://tatara-operator-internal.tatara.svc:9090",
        AnthropicSecretName: "anthropic",
        CLIOIDCSecretName:   "tatara-cli-oidc",
    }
    return proj, repo, task, cfg
}

func envValue(c corev1.Container, name string) (string, bool) {
    for _, e := range c.Env {
        if e.Name == name {
            return e.Value, true
        }
    }
    return "", false
}

func envSecretRef(c corev1.Container, name string) (*corev1.SecretKeySelector, bool) {
    for _, e := range c.Env {
        if e.Name == name && e.ValueFrom != nil && e.ValueFrom.SecretKeyRef != nil {
            return e.ValueFrom.SecretKeyRef, true
        }
    }
    return nil, false
}

func TestBuildPod_NameAndImageAndOwner(t *testing.T) {
    proj, repo, task, cfg := sampleInputs()
    pod := agent.BuildPod(proj, repo, task, cfg)

    require.Equal(t, agent.PodName(task), pod.Name)
    require.Equal(t, "tatara", pod.Namespace)
    require.Len(t, pod.Spec.Containers, 1)
    require.Equal(t, "wrapper:1", pod.Spec.Containers[0].Image)

    require.Len(t, pod.OwnerReferences, 1)
    or := pod.OwnerReferences[0]
    require.Equal(t, "Task", or.Kind)
    require.Equal(t, "task-7", or.Name)
    require.Equal(t, "uid-task-7", string(or.UID))
    require.True(t, or.Controller != nil && *or.Controller)
}

func TestBuildPod_PlainEnv(t *testing.T) {
    proj, repo, task, cfg := sampleInputs()
    c := agent.BuildPod(proj, repo, task, cfg).Spec.Containers[0]

    checks := map[string]string{
        "REPO_URL":             "https://git/acme/repo1",
        "REPO_BRANCH":          "main",
        "MODEL":                "claude-x",
        "PERMISSION_MODE":      "bypassPermissions",
        "TURN_TIMEOUT_SECONDS": "1800",
        "DEFAULT_CALLBACK_URL": "http://tatara-operator-internal.tatara.svc:9090/internal/turn-complete",
    }
    for k, want := range checks {
        got, ok := envValue(c, k)
        require.True(t, ok, "env %s missing", k)
        require.Equal(t, want, got, "env %s", k)
    }
}

func TestBuildPod_SecretEnv(t *testing.T) {
    proj, repo, task, cfg := sampleInputs()
    c := agent.BuildPod(proj, repo, task, cfg).Spec.Containers[0]

    ant, ok := envSecretRef(c, "ANTHROPIC_API_KEY")
    require.True(t, ok)
    require.Equal(t, "anthropic", ant.Name)
    require.Equal(t, "api-key", ant.Key)

    git, ok := envSecretRef(c, "GIT_TOKEN")
    require.True(t, ok)
    require.Equal(t, "demo-scm", git.Name)
    require.Equal(t, "token", git.Key)

    cid, ok := envSecretRef(c, "CLI_OIDC_CLIENT_ID")
    require.True(t, ok)
    require.Equal(t, "tatara-cli-oidc", cid.Name)
    require.Equal(t, "client-id", cid.Key)

    csec, ok := envSecretRef(c, "CLI_OIDC_CLIENT_SECRET")
    require.True(t, ok)
    require.Equal(t, "tatara-cli-oidc", csec.Name)
    require.Equal(t, "client-secret", csec.Key)
}

func TestBuildPod_PortAndReadiness(t *testing.T) {
    proj, repo, task, cfg := sampleInputs()
    c := agent.BuildPod(proj, repo, task, cfg).Spec.Containers[0]
    require.Len(t, c.Ports, 1)
    require.Equal(t, int32(8080), c.Ports[0].ContainerPort)
    require.NotNil(t, c.ReadinessProbe)
    require.Equal(t, "/readyz", c.ReadinessProbe.HTTPGet.Path)
}

func TestBuildService_MatchesPod(t *testing.T) {
    proj, repo, task, cfg := sampleInputs()
    svc := agent.BuildService(proj, repo, task, cfg)
    pod := agent.BuildPod(proj, repo, task, cfg)

    require.Equal(t, pod.Name, svc.Name) // service name == pod name
    require.Equal(t, "tatara", svc.Namespace)
    require.Equal(t, pod.Labels, svc.Spec.Selector)
    require.Len(t, svc.Spec.Ports, 1)
    require.Equal(t, int32(8080), svc.Spec.Ports[0].Port)

    require.Len(t, svc.OwnerReferences, 1)
    require.Equal(t, "Task", svc.OwnerReferences[0].Kind)
}

package agent

import (
    "strconv"

    corev1 "k8s.io/api/core/v1"
    metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
    "k8s.io/apimachinery/pkg/util/intstr"

    tatarav1alpha1 "github.com/szymonrychu/tatara-operator/api/v1alpha1"
)

// wrapperPort is the wrapper's in-pod HTTP listener.
const wrapperPort = 8080

// PodConfig holds the operator-level inputs the Pod/Service builders need that
// do not come from the CRDs.
type PodConfig struct {
    Namespace           string
    InternalAddr        string // operator INTERNAL_ADDR, e.g. http://...:9090
    AnthropicSecretName string
    CLIOIDCSecretName   string
}

// PodName returns the deterministic wrapper Pod (and Service) name for a Task.
func PodName(task *tatarav1alpha1.Task) string {
    return "wrapper-" + task.Name
}

func podLabels(task *tatarav1alpha1.Task) map[string]string {
    return map[string]string{
        "app.kubernetes.io/name":      "tatara-operator",
        "app.kubernetes.io/component": "agent",
        "tatara.dev/managed-by":       "tatara-operator",
        "tatara.dev/task":             task.Name,
    }
}

func ownerRef(task *tatarav1alpha1.Task) metav1.OwnerReference {
    controller := true
    return metav1.OwnerReference{
        APIVersion: tatarav1alpha1.GroupVersion.String(),
        Kind:       "Task",
        Name:       task.Name,
        UID:        task.UID,
        Controller: &controller,
    }
}

func secretEnv(name, secretName, key string) corev1.EnvVar {
    return corev1.EnvVar{
        Name: name,
        ValueFrom: &corev1.EnvVarSource{
            SecretKeyRef: &corev1.SecretKeySelector{
                LocalObjectReference: corev1.LocalObjectReference{Name: secretName},
                Key:                  key,
            },
        },
    }
}

// BuildPod returns the wrapper Pod for a Task, owner-referenced to the Task.
func BuildPod(project *tatarav1alpha1.Project, repo *tatarav1alpha1.Repository, task *tatarav1alpha1.Task, cfg PodConfig) *corev1.Pod {
    env := []corev1.EnvVar{
        {Name: "REPO_URL", Value: repo.Spec.URL},
        {Name: "REPO_BRANCH", Value: repo.Spec.DefaultBranch},
        {Name: "MODEL", Value: project.Spec.Agent.Model},
        {Name: "PERMISSION_MODE", Value: project.Spec.Agent.PermissionMode},
        {Name: "TURN_TIMEOUT_SECONDS", Value: strconv.Itoa(project.Spec.Agent.TurnTimeoutSeconds)},
        {Name: "DEFAULT_CALLBACK_URL", Value: cfg.InternalAddr + "/internal/turn-complete"},
        secretEnv("ANTHROPIC_API_KEY", cfg.AnthropicSecretName, "api-key"),
        secretEnv("GIT_TOKEN", project.Spec.ScmSecretRef, "token"),
        secretEnv("CLI_OIDC_CLIENT_ID", cfg.CLIOIDCSecretName, "client-id"),
        secretEnv("CLI_OIDC_CLIENT_SECRET", cfg.CLIOIDCSecretName, "client-secret"),
    }

    return &corev1.Pod{
        ObjectMeta: metav1.ObjectMeta{
            Name:            PodName(task),
            Namespace:       cfg.Namespace,
            Labels:          podLabels(task),
            OwnerReferences: []metav1.OwnerReference{ownerRef(task)},
        },
        Spec: corev1.PodSpec{
            RestartPolicy: corev1.RestartPolicyNever,
            Containers: []corev1.Container{{
                Name:  "wrapper",
                Image: project.Spec.Agent.Image,
                Env:   env,
                Ports: []corev1.ContainerPort{{ContainerPort: wrapperPort}},
                ReadinessProbe: &corev1.Probe{
                    ProbeHandler: corev1.ProbeHandler{
                        HTTPGet: &corev1.HTTPGetAction{
                            Path: "/readyz",
                            Port: intstr.FromInt(wrapperPort),
                        },
                    },
                },
            }},
        },
    }
}

// BuildService returns the ClusterIP Service fronting the wrapper Pod. Its name
// equals the Pod name so the operator can address the wrapper at
// http://<name>.<ns>.svc:8080.
func BuildService(project *tatarav1alpha1.Project, repo *tatarav1alpha1.Repository, task *tatarav1alpha1.Task, cfg PodConfig) *corev1.Service {
    return &corev1.Service{
        ObjectMeta: metav1.ObjectMeta{
            Name:            PodName(task),
            Namespace:       cfg.Namespace,
            Labels:          podLabels(task),
            OwnerReferences: []metav1.OwnerReference{ownerRef(task)},
        },
        Spec: corev1.ServiceSpec{
            Selector: podLabels(task),
            Ports: []corev1.ServicePort{{
                Port:       wrapperPort,
                TargetPort: intstr.FromInt(wrapperPort),
            }},
        },
    }
}

// BaseURL returns the in-cluster wrapper address for a Task's Service.
func BaseURL(task *tatarav1alpha1.Task, namespace string) string {
    return "http://" + PodName(task) + "." + namespace + ".svc:" + strconv.Itoa(wrapperPort)
}

package controller

import (
    "strings"
    "testing"

    tatarav1alpha1 "github.com/szymonrychu/tatara-operator/api/v1alpha1"
)

func sub(name string, order int, phase string) tatarav1alpha1.Subtask {
    s := tatarav1alpha1.Subtask{}
    s.Name = name
    s.Spec.Order = order
    s.Spec.Title = name + "-title"
    s.Spec.Detail = name + "-detail"
    s.Status.Phase = phase
    return s
}

func TestPlanTurnText_MentionsDecompose(t *testing.T) {
    txt := planTurnText("ship the feature")
    if !strings.Contains(txt, "ship the feature") {
        t.Errorf("plan turn missing goal: %q", txt)
    }
    if !strings.Contains(strings.ToLower(txt), "subtask") {
        t.Errorf("plan turn missing subtask MCP instruction: %q", txt)
    }
}

func TestNextPendingSubtask_PicksLowestOrder(t *testing.T) {
    subs := []tatarav1alpha1.Subtask{
        sub("c", 3, "Pending"),
        sub("a", 1, "Done"),
        sub("b", 2, "Pending"),
    }
    got, ok := nextPendingSubtask(subs)
    if !ok {
        t.Fatal("expected a pending subtask")
    }
    if got.Name != "b" {
        t.Errorf("next = %q, want b (lowest-order Pending)", got.Name)
    }
}

func TestNextPendingSubtask_NoneLeft(t *testing.T) {
    subs := []tatarav1alpha1.Subtask{sub("a", 1, "Done"), sub("b", 2, "Done")}
    if _, ok := nextPendingSubtask(subs); ok {
        t.Error("expected no pending subtask")
    }
}

func TestTurnText_TitleAndDetail(t *testing.T) {
    txt := turnText(sub("x", 1, "Pending"))
    if !strings.Contains(txt, "x-title") || !strings.Contains(txt, "x-detail") {
        t.Errorf("turn text missing title/detail: %q", txt)
    }
}

package controller

import (
    "fmt"
    "sort"

    tatarav1alpha1 "github.com/szymonrychu/tatara-operator/api/v1alpha1"
)

// planTurnText is the turn-0 prompt: the goal plus the instruction to
// decompose the work into Subtasks via the subtask MCP tool.
func planTurnText(goal string) string {
    return fmt.Sprintf(
        "%s\n\nDecompose this objective into ordered Subtasks via the subtask MCP tool "+
            "(subtask_create), one per concrete step. Do not start implementation in this turn.",
        goal)
}

// nextPendingSubtask returns the lowest-order Pending subtask, if any.
func nextPendingSubtask(subs []tatarav1alpha1.Subtask) (*tatarav1alpha1.Subtask, bool) {
    pending := make([]tatarav1alpha1.Subtask, 0, len(subs))
    for i := range subs {
        if subs[i].Status.Phase == "Pending" || subs[i].Status.Phase == "" {
            pending = append(pending, subs[i])
        }
    }
    if len(pending) == 0 {
        return nil, false
    }
    sort.Slice(pending, func(i, j int) bool { return pending[i].Spec.Order < pending[j].Spec.Order })
    out := pending[0]
    return &out, true
}

// turnText is the prompt for executing one Subtask.
func turnText(sub tatarav1alpha1.Subtask) string {
    return fmt.Sprintf("Subtask: %s\n\n%s", sub.Spec.Title, sub.Spec.Detail)
}