package v1alpha1

import (
    "encoding/json"
    "testing"
)

func TestNewFields_JSONRoundTrip(t *testing.T) {
    tests := []struct {
        name    string
        marshal func() ([]byte, error)
        want    string
    }{
        {
            name: "AgentSpec.Effort json key effort",
            marshal: func() ([]byte, error) {
                return json.Marshal(AgentSpec{Effort: "max"})
            },
            want: `"effort":"max"`,
        },
        {
            name: "TaskSource.Title json key title",
            marshal: func() ([]byte, error) {
                return json.Marshal(TaskSource{Provider: "github", IssueRef: "o/r#1", Title: "fix the thing"})
            },
            want: `"title":"fix the thing"`,
        },
        {
            name: "ProposedIssueSpec.SystemicID json key systemicId",
            marshal: func() ([]byte, error) {
                return json.Marshal(ProposedIssueSpec{RepositoryRef: "r", Title: "t", Body: "b", Kind: "bug", SystemicID: "abc123"})
            },
            want: `"systemicId":"abc123"`,
        },
    }
    for _, tc := range tests {
        t.Run(tc.name, func(t *testing.T) {
            b, err := tc.marshal()
            if err != nil {
                t.Fatalf("marshal: %v", err)
            }
            if !jsonContains(string(b), tc.want) {
                t.Fatalf("json %s does not contain %s", b, tc.want)
            }
        })
    }
}

func jsonContains(haystack, needle string) bool {
    return len(haystack) >= len(needle) && (func() bool {
        for i := 0; i+len(needle) <= len(haystack); i++ {
            if haystack[i:i+len(needle)] == needle {
                return true
            }
        }
        return false
    })()
}

    // Effort is the reasoning-effort level passed to the wrapper agent as the
    // EFFORT env var (the "ultracode" lever). Highest by default.
    // +kubebuilder:validation:Enum=low;medium;high;xhigh;max
    // +kubebuilder:default="xhigh"
    // +optional
    Effort string `json:"effort,omitempty"`

    // SystemicID correlates one of several issues opened for a single systemic
    // improvement. When set, createProposal stamps label tatara/systemic-<id>
    // and a sibling footer; the group counts as one against maxOpenProposals.
    // +optional
    SystemicID string `json:"systemicId,omitempty"`

    // Title is the originating issue/PR/MR title, captured at enqueue. Feeds the
    // branch slug (TaskBranch) and the no-agent PR-title fallback.
    // +optional
    Title string `json:"title,omitempty"`

package scm

import (
    "context"
    "encoding/json"
    "net/http"
    "net/http/httptest"
    "net/url"
    "strings"
    "testing"
)

func TestGitHubGetDefaultBranchHeadSHA(t *testing.T) {
    tests := []struct {
        name        string
        defBranch   string
        commitSHA   string
        wantSHA     string
        repoStatus  int
        wantErr     bool
    }{
        {name: "resolves main head", defBranch: "main", commitSHA: "abc123", wantSHA: "abc123"},
        {name: "non-default branch name", defBranch: "trunk", commitSHA: "def456", wantSHA: "def456"},
        {name: "repo 404 errors", defBranch: "main", repoStatus: http.StatusNotFound, wantErr: true},
    }
    for _, tc := range tests {
        t.Run(tc.name, func(t *testing.T) {
            srv := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
                switch {
                case r.URL.Path == "/repos/o/r":
                    if tc.repoStatus != 0 {
                        w.WriteHeader(tc.repoStatus)
                        return
                    }
                    _ = json.NewEncoder(w).Encode(map[string]any{"default_branch": tc.defBranch})
                case r.URL.Path == "/repos/o/r/commits/"+tc.defBranch:
                    _ = json.NewEncoder(w).Encode(map[string]any{"sha": tc.commitSHA})
                default:
                    t.Errorf("unexpected path %q", r.URL.Path)
                    w.WriteHeader(http.StatusNotFound)
                }
            }))
            defer srv.Close()
            c := &GitHub{apiBase: srv.URL}
            got, err := c.GetDefaultBranchHeadSHA(context.Background(), "o", "r")
            if tc.wantErr {
                if err == nil {
                    t.Fatalf("want error, got sha %q", got)
                }
                return
            }
            if err != nil {
                t.Fatalf("GetDefaultBranchHeadSHA: %v", err)
            }
            if got != tc.wantSHA {
                t.Fatalf("sha = %q, want %q", got, tc.wantSHA)
            }
        })
    }
}

func TestGitLabGetDefaultBranchHeadSHA(t *testing.T) {
    const proj = "grp/proj"
    tests := []struct {
        name      string
        defBranch string
        commitID  string
        wantSHA   string
    }{
        {name: "resolves default branch", defBranch: "main", commitID: "sha-main", wantSHA: "sha-main"},
        {name: "custom default branch", defBranch: "develop", commitID: "sha-dev", wantSHA: "sha-dev"},
    }
    for _, tc := range tests {
        t.Run(tc.name, func(t *testing.T) {
            esc := url.PathEscape(proj)
            srv := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
                switch {
                case r.URL.Path == "/projects/"+esc:
                    _ = json.NewEncoder(w).Encode(map[string]any{"default_branch": tc.defBranch})
                case strings.HasPrefix(r.URL.Path, "/projects/"+esc+"/repository/branches/"):
                    _ = json.NewEncoder(w).Encode(map[string]any{"commit": map[string]any{"id": tc.commitID}})
                default:
                    t.Errorf("unexpected path %q", r.URL.Path)
                    w.WriteHeader(http.StatusNotFound)
                }
            }))
            defer srv.Close()
            c := &GitLab{apiBase: srv.URL}
            got, err := c.GetDefaultBranchHeadSHA(context.Background(), proj, "")
            if err != nil {
                t.Fatalf("GetDefaultBranchHeadSHA: %v", err)
            }
            if got != tc.wantSHA {
                t.Fatalf("sha = %q, want %q", got, tc.wantSHA)
            }
        })
    }
}

    // GetDefaultBranchHeadSHA resolves the default branch HEAD commit sha.
    // For GitLab owner carries the full project path; repo is unused. Paired
    // with GetCommitCIStatus to report per-repo main-branch CI health.
    GetDefaultBranchHeadSHA(ctx context.Context, owner, repo string) (string, error)

// GetDefaultBranchHeadSHA resolves the default branch HEAD commit sha for owner/repo.
func (c *GitHub) GetDefaultBranchHeadSHA(ctx context.Context, owner, repo string) (string, error) {
    var meta struct {
        DefaultBranch string `json:"default_branch"`
    }
    if err := ghDo(ctx, c.base(), http.MethodGet, fmt.Sprintf("/repos/%s/%s", owner, repo), c.token, nil, &meta); err != nil {
        return "", fmt.Errorf("github: get repo meta %s/%s: %w", owner, repo, err)
    }
    if meta.DefaultBranch == "" {
        return "", fmt.Errorf("github: empty default_branch for %s/%s", owner, repo)
    }
    var commit struct {
        SHA string `json:"sha"`
    }
    if err := ghDo(ctx, c.base(), http.MethodGet, fmt.Sprintf("/repos/%s/%s/commits/%s", owner, repo, meta.DefaultBranch), c.token, nil, &commit); err != nil {
        return "", fmt.Errorf("github: get default branch head %s/%s@%s: %w", owner, repo, meta.DefaultBranch, err)
    }
    return commit.SHA, nil
}

// GetDefaultBranchHeadSHA resolves the default branch HEAD commit sha. owner
// carries the full project path; repo is unused (matches GetCommitCIStatus).
func (c *GitLab) GetDefaultBranchHeadSHA(ctx context.Context, owner, _ /*repo*/ string) (string, error) {
    esc := url.PathEscape(owner)
    var meta struct {
        DefaultBranch string `json:"default_branch"`
    }
    if err := glDo(ctx, c.base(), http.MethodGet, "/projects/"+esc, c.token, nil, &meta); err != nil {
        return "", fmt.Errorf("gitlab: get project meta %s: %w", owner, err)
    }
    if meta.DefaultBranch == "" {
        return "", fmt.Errorf("gitlab: empty default_branch for %s", owner)
    }
    var branch struct {
        Commit struct {
            ID string `json:"id"`
        } `json:"commit"`
    }
    path := "/projects/" + esc + "/repository/branches/" + url.PathEscape(meta.DefaultBranch)
    if err := glDo(ctx, c.base(), http.MethodGet, path, c.token, nil, &branch); err != nil {
        return "", fmt.Errorf("gitlab: get default branch head %s@%s: %w", owner, meta.DefaultBranch, err)
    }
    return branch.Commit.ID, nil
}

func (f *fakeReader) GetDefaultBranchHeadSHA(context.Context, string, string) (string, error) {
    return "", nil
}

func TestCreateScanTask_SetsSourceTitle(t *testing.T) {
    tests := []struct {
        name      string
        cand      candidate
        wantTitle string
    }{
        {name: "issue title threaded", cand: candidate{repo: "o/r", number: 7, title: "Fix flaky CI on push"}, wantTitle: "Fix flaky CI on push"},
        {name: "empty title stays empty", cand: candidate{repo: "o/r", number: 8}, wantTitle: ""},
    }
    for _, tc := range tests {
        t.Run(tc.name, func(t *testing.T) {
            src := scanSourceFor(provider, tc.cand) // helper extracted in impl
            if src.Title != tc.wantTitle {
                t.Fatalf("Source.Title = %q, want %q", src.Title, tc.wantTitle)
            }
        })
    }
}

package agent

import (
    "strings"
    "testing"

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

func taskWith(name, kind string, num int, title string, isPR bool) *tatarav1alpha1.Task {
    t := &tatarav1alpha1.Task{}
    t.Name = name
    t.Spec.Kind = kind
    if num > 0 || title != "" {
        t.Spec.Source = &tatarav1alpha1.TaskSource{Number: num, Title: title, IsPR: isPR}
    }
    return t
}

func TestTaskBranch(t *testing.T) {
    tests := []struct {
        name string
        task *tatarav1alpha1.Task
        want string
    }{
        {"issue numbered fix", taskWith("scan-abc", "issueLifecycle", 42, "Fix flaky CI on push events", false), "tatara/fix-42-fix-flaky-ci-on-push-events"},
        {"pr review is chore", taskWith("scan-def", "review", 7, "Review: add metrics", true), "tatara/chore-7-review-add-metrics"},
        {"no number falls back", taskWith("brainstorm-xyz", "brainstorm", 0, "", false), "tatara/task-brainstorm-xyz"},
        {"empty title still numbered", taskWith("scan-ghi", "issueLifecycle", 9, "", false), "tatara/fix-9"},
        {"long title truncated", taskWith("scan-jkl", "issueLifecycle", 1, strings.Repeat("very long word ", 10), false), ""},
    }
    for _, tc := range tests {
        t.Run(tc.name, func(t *testing.T) {
            got := TaskBranch(tc.task)
            if tc.want != "" && got != tc.want {
                t.Fatalf("TaskBranch = %q, want %q", got, tc.want)
            }
            if len(got) > 63 {
                t.Fatalf("branch %q exceeds 63 chars", got)
            }
            if !strings.HasPrefix(got, "tatara/") {
                t.Fatalf("branch %q missing tatara/ prefix", got)
            }
        })
    }
}

func TestSlugifyTitle(t *testing.T) {
    tests := []struct{ in, want string }{
        {"Fix flaky CI on push events", "fix-flaky-ci-on-push-events"},
        {"  Trim   Spaces  ", "trim-spaces"},
        {"Special!@#chars$%^here", "special-chars-here"},
        {"", ""},
        {strings.Repeat("a", 60), strings.Repeat("a", 40)},
    }
    for _, tc := range tests {
        t.Run(tc.in, func(t *testing.T) {
            if got := slugifyTitle(tc.in); got != tc.want {
                t.Fatalf("slugifyTitle(%q) = %q, want %q", tc.in, got, tc.want)
            }
        })
    }
}

func TestBranchKind(t *testing.T) {
    tests := []struct {
        name string
        task *tatarav1alpha1.Task
        want string
    }{
        {"issueLifecycle is fix", taskWith("a", "issueLifecycle", 1, "x", false), "fix"},
        {"implement is feat", taskWith("b", "implement", 1, "x", false), "feat"},
        {"review is chore", taskWith("c", "review", 1, "x", true), "chore"},
        {"brainstorm is chore", taskWith("d", "brainstorm", 0, "", false), "chore"},
    }
    for _, tc := range tests {
        t.Run(tc.name, func(t *testing.T) {
            if got := branchKind(tc.task); got != tc.want {
                t.Fatalf("branchKind = %q, want %q", got, tc.want)
            }
        })
    }
}

// slugifyTitle lowercases s, collapses every run of non-[a-z0-9] into a single
// '-', trims leading/trailing '-', and caps at 40 chars (trimmed again so a cut
// never leaves a trailing '-').
func slugifyTitle(s string) string {
    s = strings.ToLower(s)
    var b strings.Builder
    prevDash := false
    for _, r := range s {
        if (r >= 'a' && r <= 'z') || (r >= '0' && r <= '9') {
            b.WriteRune(r)
            prevDash = false
        } else if !prevDash {
            b.WriteByte('-')
            prevDash = true
        }
    }
    out := strings.Trim(b.String(), "-")
    if len(out) > 40 {
        out = strings.Trim(out[:40], "-")
    }
    return out
}

// branchKind maps a Task to a conventional branch prefix.
func branchKind(t *tatarav1alpha1.Task) string {
    switch t.Spec.Kind {
    case "issueLifecycle", "incident":
        return "fix"
    case "implement":
        return "feat"
    default: // review, brainstorm, healthCheck, selfImprove, triageIssue
        return "chore"
    }
}

// TaskBranch is the deterministic work branch all of the operator write-back,
// the turn prompts, and the wrapper agree on. When the Task carries an issue/PR
// number it is tatara/<kind>-<number>-<slug>; otherwise tatara/task-<task-name>.
func TaskBranch(t *tatarav1alpha1.Task) string {
    if t.Spec.Source != nil && t.Spec.Source.Number > 0 {
        base := fmt.Sprintf("tatara/%s-%d", branchKind(t), t.Spec.Source.Number)
        if slug := slugifyTitle(t.Spec.Source.Title); slug != "" {
            base += "-" + slug
        }
        if len(base) > 63 {
            base = strings.Trim(base[:63], "-")
        }
        return base
    }
    return "tatara/task-" + t.Name
}

package agent

import (
    "testing"

    tatarav1alpha1 "github.com/szymonrychu/tatara-operator/api/v1alpha1"
    corev1 "k8s.io/api/core/v1"
)

func envValue(env []corev1.EnvVar, name string) (string, bool) {
    for _, e := range env {
        if e.Name == name {
            return e.Value, true
        }
    }
    return "", false
}

func TestBuildPod_SetsEffortEnv(t *testing.T) {
    tests := []struct {
        name   string
        effort string
        want   string
    }{
        {"xhigh default", "xhigh", "xhigh"},
        {"max", "max", "max"},
        {"empty still emitted", "", ""},
    }
    for _, tc := range tests {
        t.Run(tc.name, func(t *testing.T) {
            proj := &tatarav1alpha1.Project{}
            proj.Name = "p"
            proj.Spec.Agent.Effort = tc.effort
            task := &tatarav1alpha1.Task{}
            task.Name = "t"
            pod := BuildPod(proj, nil, task, nil, "http://mem", PodConfig{})
            got, ok := envValue(pod.Spec.Containers[0].Env, "EFFORT")
            if !ok {
                t.Fatalf("EFFORT env not set")
            }
            if got != tc.want {
                t.Fatalf("EFFORT = %q, want %q", got, tc.want)
            }
        })
    }
}

        {Name: "MODEL", Value: project.Spec.Agent.Model},
        {Name: "EFFORT", Value: project.Spec.Agent.Effort},
        {Name: "PERMISSION_MODE", Value: project.Spec.Agent.PermissionMode},

package controller

import "testing"

func TestWeakTitle(t *testing.T) {
    tests := []struct {
        name     string
        in       string
        wantWeak bool
    }{
        {"empty", "", true},
        {"bare go", "Go", true},
        {"bare update", "update", true},
        {"too short", "fix bug", true},
        {"two words", "fix everything", true},
        {"denylist wip", "wip", true},
        {"good conventional", "fix(scan): dedup brainstorm proposals by systemic label", false},
        {"good plain", "Add main-branch CI health to the brainstorm survey", false},
    }
    for _, tc := range tests {
        t.Run(tc.name, func(t *testing.T) {
            gotWeak, guidance := weakTitle(tc.in)
            if gotWeak != tc.wantWeak {
                t.Fatalf("weakTitle(%q) weak = %v, want %v", tc.in, gotWeak, tc.wantWeak)
            }
            if gotWeak && guidance == "" {
                t.Fatalf("weakTitle(%q) weak but empty guidance", tc.in)
            }
            if !gotWeak && guidance != "" {
                t.Fatalf("weakTitle(%q) strong but non-empty guidance %q", tc.in, guidance)
            }
        })
    }
}

// weakTitleDenylist are bare tokens that, alone, make a useless title.
var weakTitleDenylist = map[string]bool{
    "go": true, "update": true, "fix": true, "change": true, "wip": true,
    "misc": true, "chore": true, "stuff": true, "changes": true, "updates": true,
    "python": true, "golang": true, "helm": true, "docker": true, "ci": true,
}

// weakTitle reports whether a proposed issue/PR title is too weak to emit and,
// when weak, a one-line guidance message the agent can act on that same turn.
func weakTitle(s string) (bool, string) {
    t := strings.TrimSpace(s)
    if t == "" {
        return true, "title is empty: provide a descriptive, conventional title (e.g. 'fix(scope): concrete change')"
    }
    if len(t) < 12 {
        return true, fmt.Sprintf("title %q is too short (<12 chars): describe the concrete change", t)
    }
    if len(strings.Fields(t)) <= 2 {
        return true, fmt.Sprintf("title %q has too few words (<=2): name the component and the change", t)
    }
    if weakTitleDenylist[strings.ToLower(t)] {
        return true, fmt.Sprintf("title %q is a bare token: describe the concrete change instead", t)
    }
    return false, ""
}

func TestProposeIssue_WeakTitleRejected(t *testing.T) {
    tests := []struct {
        name       string
        title      string
        wantStatus int
    }{
        {"weak bare go rejected", "Go", http.StatusBadRequest},
        {"empty rejected", "", http.StatusBadRequest},
        {"good accepted", "Add systemic correlation labels to proposals", http.StatusCreated},
    }
    for _, tc := range tests {
        t.Run(tc.name, func(t *testing.T) {
            // ... build server with fake client containing project p + repo r ...
            body := fmt.Sprintf(`{"repositoryRef":"r","title":%q,"body":"a real body here","kind":"bug"}`, tc.title)
            rec := doRequest(t, srv, http.MethodPost, "/projects/p/issues", body)
            if rec.Code != tc.wantStatus {
                t.Fatalf("status = %d, want %d (body %s)", rec.Code, tc.wantStatus, rec.Body.String())
            }
        })
    }
}

func TestProposeIssue_SystemicIDThreaded(t *testing.T) {
    // POST with "systemicId":"grp1"; assert the created Task's
    // Spec.ProposedIssue.SystemicID == "grp1" via the fake client Get.
}

    if weak, guidance := titlecheck.Weak(req.Title); weak {
        writeError(w, http.StatusBadRequest, "weak title: "+guidance)
        return
    }

            ProposedIssue: &tatarav1alpha1.ProposedIssueSpec{
                RepositoryRef: req.RepositoryRef, Title: req.Title, Body: req.Body,
                Kind: req.Kind, SystemicID: req.SystemicID,
            },

    if req.PRTitle != "" {
        if weak, guidance := titlecheck.Weak(req.PRTitle); weak {
            writeError(w, http.StatusBadRequest, "weak pr title: "+guidance)
            return
        }
    }

func TestProposalBacklogCount_GroupsSystemic(t *testing.T) {
    const bs = "tatara-brainstorming"
    mk := func(n int, labels ...string) scm.IssueRef {
        return scm.IssueRef{Repo: "o/r", Number: n, Labels: append([]string{bs}, labels...)}
    }
    tests := []struct {
        name string
        iss  []scm.IssueRef
        want int
    }{
        {"three standalone count three", []scm.IssueRef{mk(1), mk(2), mk(3)}, 3},
        {"systemic group counts one", []scm.IssueRef{mk(1, "tatara/systemic-abc"), mk(2, "tatara/systemic-abc"), mk(3, "tatara/systemic-abc")}, 1},
        {"mixed: group + standalone", []scm.IssueRef{mk(1, "tatara/systemic-abc"), mk(2, "tatara/systemic-abc"), mk(3)}, 2},
        {"two distinct groups", []scm.IssueRef{mk(1, "tatara/systemic-abc"), mk(2, "tatara/systemic-def")}, 2},
    }
    for _, tc := range tests {
        t.Run(tc.name, func(t *testing.T) {
            if got := proposalBacklogCount(tc.iss, bs, "tatara-idea"); got != tc.want {
                t.Fatalf("proposalBacklogCount = %d, want %d", got, tc.want)
            }
        })
    }
}

    const systemicPrefix = "tatara/systemic-"
    groups := map[string]bool{}
    standalone := 0
    for _, iss := range proposals { // proposals = the already-filtered set
        sid := ""
        for _, l := range iss.Labels {
            if strings.HasPrefix(l, systemicPrefix) {
                sid = l
                break
            }
        }
        if sid != "" {
            groups[sid] = true
        } else {
            standalone++
        }
    }
    return standalone + len(groups)

    labels := []string{label}
    body := task.Spec.ProposedIssue.Body
    if sid := task.Spec.ProposedIssue.SystemicID; sid != "" {
        labels = append(labels, "tatara/systemic-"+sid)
        body += fmt.Sprintf("\n\nPart of systemic improvement %s spanning: %s", sid, systemicRepoList(proj))
    }
    body += "\n\n" + tataraAuthoredMarker

func TestDerivePRTitle(t *testing.T) {
    mk := func(kind, srcTitle, csTitle, goal string) *tatarav1alpha1.Task {
        ta := &tatarav1alpha1.Task{}
        ta.Spec.Kind = kind
        ta.Spec.Goal = goal
        if srcTitle != "" {
            ta.Spec.Source = &tatarav1alpha1.TaskSource{Title: srcTitle}
        }
        if csTitle != "" {
            ta.Status.ChangeSummary = &tatarav1alpha1.ChangeSummary{PRTitle: csTitle}
        }
        return ta
    }
    tests := []struct {
        name string
        task *tatarav1alpha1.Task
        want string
    }{
        {"strong changesummary wins", mk("issueLifecycle", "Fix flaky CI", "fix(ci): retry flaky push checks", "body line"), "fix(ci): retry flaky push checks"},
        {"weak changesummary derives", mk("issueLifecycle", "Add main-branch CI health survey", "Go", "body line"), "fix(repo): Add main-branch CI health survey"},
        {"absent changesummary derives", mk("implement", "Thread systemicId through propose_issue", "", "issue body first line"), "feat(repo): Thread systemicId through propose_issue"},
        {"no source title falls to goal-ish but not weak", mk("issueLifecycle", "", "", "Make the brainstorm survey live state"), "fix(repo): Make the brainstorm survey live state"},
    }
    for _, tc := range tests {
        t.Run(tc.name, func(t *testing.T) {
            if got := derivePRTitle(tc.task, "repo"); got != tc.want {
                t.Fatalf("derivePRTitle = %q, want %q", got, tc.want)
            }
        })
    }
}

// derivePRTitle returns the PR/MR title for a write-back. A strong
// ChangeSummary.PRTitle wins; otherwise it derives a conventional title from the
// captured work-item title (Source.Title), falling back to the goal first line.
// It never returns a weak title.
func derivePRTitle(task *tatarav1alpha1.Task, scope string) string {
    if cs := task.Status.ChangeSummary; cs != nil && cs.PRTitle != "" {
        if weak, _ := titlecheck.Weak(cs.PRTitle); !weak {
            return cs.PRTitle
        }
    }
    subject := ""
    if task.Spec.Source != nil {
        subject = strings.TrimSpace(task.Spec.Source.Title)
    }
    if subject == "" {
        subject = firstLine(task.Spec.Goal)
    }
    kind := "feat"
    switch task.Spec.Kind {
    case "issueLifecycle", "incident":
        kind = "fix"
    }
    return fmt.Sprintf("%s(%s): %s", kind, scope, subject)
}

    title := derivePRTitle(task, primaryRepo.Name)
    baseBody := writeBackBody(task)
    if cs := task.Status.ChangeSummary; cs != nil {
        deliveredBody := cs.PRBody
        if cs.DeliveredScope != "" {
            deliveredBody += "\n\n## Delivered\n" + cs.DeliveredScope
        }
        deliveredBody += "\n\n" + tataraAuthoredMarker
        baseBody = deliveredBody
    }