builder_test.go

package context

import (
	stdcontext "context"
	"fmt"
	"os"
	"path/filepath"
	"strings"
	"testing"
	"time"

	"neo-code/internal/config"
	"neo-code/internal/context/internalcompact"
	providertypes "neo-code/internal/provider/types"
	"neo-code/internal/rules"
	agentsession "neo-code/internal/session"
)

const maxRetainedMessageSpans = config.DefaultCompactReadTimeMaxMessageSpans

type stubPromptSectionSource struct {
	sections []promptSection
	err      error
}

func (s stubPromptSectionSource) Sections(ctx stdcontext.Context, input BuildInput) ([]promptSection, error) {
	if s.err != nil {
		return nil, s.err
	}
	return append([]promptSection(nil), s.sections...), nil
}

func TestDefaultBuilderBuild(t *testing.T) {
	t.Parallel()

	builder := NewBuilder()
	input := BuildInput{
		Messages: []providertypes.Message{
			{Role: "user", Parts: []providertypes.ContentPart{providertypes.NewTextPart("hello")}},
		},
		Metadata: testMetadata(t.TempDir()),
	}

	got, err := builder.Build(stdcontext.Background(), input)
	if err != nil {
		t.Fatalf("Build() error = %v", err)
	}
	if got.SystemPrompt == "" {
		t.Fatalf("expected non-empty system prompt")
	}
	if !strings.Contains(got.SystemPrompt, "## Agent Identity") {
		t.Fatalf("expected core prompt sections to be included")
	}
	if !strings.Contains(got.SystemPrompt, "## System State") {
		t.Fatalf("expected system state section in composed prompt")
	}
	if strings.Contains(got.SystemPrompt, "## Rules") {
		t.Fatalf("did not expect rules section without AGENTS.md")
	}
	if strings.Contains(got.SystemPrompt, "\n\n\n") {
		t.Fatalf("did not expect repeated blank lines in composed prompt")
	}
	if !strings.Contains(got.SystemPrompt, input.Metadata.Workdir) {
		t.Fatalf("expected workdir in system state section")
	}
	if len(got.Messages) != 1 {
		t.Fatalf("expected 1 message, got %d", len(got.Messages))
	}
	if &got.Messages[0] == &input.Messages[0] {
		t.Fatalf("expected messages slice to be cloned")
	}
}

func TestDefaultBuilderBuildHonorsCancellation(t *testing.T) {
	t.Parallel()

	builder := NewBuilder()
	ctx, cancel := stdcontext.WithCancel(stdcontext.Background())
	cancel()

	_, err := builder.Build(ctx, BuildInput{})
	if err != stdcontext.Canceled {
		t.Fatalf("expected context.Canceled, got %v", err)
	}
}

func TestDefaultBuilderBuildComposesPromptSectionsInOrder(t *testing.T) {
	t.Parallel()

	root := t.TempDir()
	if err := os.WriteFile(filepath.Join(root, projectRuleFileName), []byte("project-rules"), 0o644); err != nil {
		t.Fatalf("write AGENTS.md: %v", err)
	}

	builder := NewBuilder()
	got, err := builder.Build(stdcontext.Background(), BuildInput{
		Messages: []providertypes.Message{{Role: "user", Parts: []providertypes.ContentPart{providertypes.NewTextPart("hello")}}},
		Metadata: testMetadata(root),
	})
	if err != nil {
		t.Fatalf("Build() error = %v", err)
	}

	identityIndex := strings.Index(got.SystemPrompt, "## Agent Identity")
	rulesIndex := strings.Index(got.SystemPrompt, "## Rules")
	stateIndex := strings.Index(got.SystemPrompt, "## System State")
	if identityIndex < 0 || rulesIndex < 0 || stateIndex < 0 {
		t.Fatalf("expected all prompt sections, got %q", got.SystemPrompt)
	}
	if !(identityIndex < rulesIndex && rulesIndex < stateIndex) {
		t.Fatalf("expected section order core -> rules -> system state, got %q", got.SystemPrompt)
	}
}

func TestDefaultBuilderBuildIncludesTaskStateBeforeSystemState(t *testing.T) {
	t.Parallel()

	builder := NewBuilder()
	got, err := builder.Build(stdcontext.Background(), BuildInput{
		Messages: []providertypes.Message{{Role: "user", Parts: []providertypes.ContentPart{providertypes.NewTextPart("hello")}}},
		TaskState: agentsession.TaskState{
			Goal:      "Finish task state refactor",
			OpenItems: []string{"Update tests"},
			NextStep:  "Run go test ./...",
		},
		Metadata: testMetadata(t.TempDir()),
	})
	if err != nil {
		t.Fatalf("Build() error = %v", err)
	}

	taskStateIndex := strings.Index(got.SystemPrompt, "## Task State")
	systemStateIndex := strings.Index(got.SystemPrompt, "## System State")
	if taskStateIndex < 0 || systemStateIndex < 0 {
		t.Fatalf("expected task state and system state sections, got %q", got.SystemPrompt)
	}
	if taskStateIndex > systemStateIndex {
		t.Fatalf("expected task state before system state, got %q", got.SystemPrompt)
	}
	if !strings.Contains(got.SystemPrompt, "- goal: Finish task state refactor") {
		t.Fatalf("expected task state content in system prompt, got %q", got.SystemPrompt)
	}
}

func TestDefaultBuilderBuildIncludesPlanSections(t *testing.T) {
	t.Parallel()

	builder := NewBuilder()
	got, err := builder.Build(stdcontext.Background(), BuildInput{
		AgentMode: agentsession.AgentModePlan,
		PlanStage: "plan",
		CurrentPlan: &agentsession.PlanArtifact{
			ID:       "plan-1",
			Revision: 3,
			Status:   agentsession.PlanStatusDraft,
			Spec: agentsession.PlanSpec{
				Goal:        "引入 plan/build 模式",
				Steps:       []string{"扩展 session", "扩展 runtime"},
				Constraints: []string{"保持 tools 边界"},
			},
			Summary: agentsession.SummaryView{
				Goal:          "引入 plan/build 模式",
				KeySteps:      []string{"扩展 session", "扩展 runtime"},
				Constraints:   []string{"保持 tools 边界"},
				ActiveTodoIDs: []string{"todo-1"},
			},
		},
		Metadata:       testMetadata(t.TempDir()),
		InjectFullPlan: true,
	})
	if err != nil {
		t.Fatalf("Build() error = %v", err)
	}
	if !strings.Contains(got.SystemPrompt, "## Plan Mode") {
		t.Fatalf("expected plan mode section, got %q", got.SystemPrompt)
	}
	if !strings.Contains(got.SystemPrompt, "You are currently in the planning stage.") {
		t.Fatalf("expected plan mode prompt asset content, got %q", got.SystemPrompt)
	}
	if !strings.Contains(got.SystemPrompt, "## Current Plan") {
		t.Fatalf("expected current plan section, got %q", got.SystemPrompt)
	}
	if !strings.Contains(got.SystemPrompt, "full_plan_view:") {
		t.Fatalf("expected full plan view in prompt, got %q", got.SystemPrompt)
	}
}

func TestDefaultBuilderBuildPlanModeDoesNotRequireTodoWrite(t *testing.T) {
	t.Parallel()

	builder := NewBuilder()
	got, err := builder.Build(stdcontext.Background(), BuildInput{
		AgentMode: agentsession.AgentModePlan,
		PlanStage: "plan",
		Metadata:  testMetadata(t.TempDir()),
	})
	if err != nil {
		t.Fatalf("Build() error = %v", err)
	}
	if !strings.Contains(got.SystemPrompt, "Do not create execution todos in plan mode") {
		t.Fatalf("expected plan mode to forbid execution todo creation, got %q", got.SystemPrompt)
	}
	if !strings.Contains(got.SystemPrompt, "the current mode permits execution todo updates") {
		t.Fatalf("expected core todo guidance to be mode-gated, got %q", got.SystemPrompt)
	}
	for _, forbidden := range []string{
		"maintain explicit todos with `todo_write`.",
		"Maintain explicit task state and todos via `todo_write`.",
		"keep task state explicit via `todo_write` (plan/add/update/set_status/claim/complete/fail) instead of relying on implicit memory",
		"keep critical information in the task state using `todo_write` updates",
	} {
		if strings.Contains(got.SystemPrompt, forbidden) {
			t.Fatalf("plan mode prompt should not contain hard todo_write guidance %q in %q", forbidden, got.SystemPrompt)
		}
	}
}

func TestDefaultBuilderBuildIncludesTodosBeforeSystemState(t *testing.T) {
	t.Parallel()

	builder := NewBuilder()
	got, err := builder.Build(stdcontext.Background(), BuildInput{
		Messages: []providertypes.Message{{Role: "user", Parts: []providertypes.ContentPart{providertypes.NewTextPart("hello")}}},
		Todos: []agentsession.TodoItem{
			{
				ID:        "todo-1",
				Content:   "implement todo tool",
				Status:    agentsession.TodoStatusInProgress,
				Priority:  3,
				Revision:  2,
				CreatedAt: time.Now(),
			},
		},
		Metadata: testMetadata(t.TempDir()),
	})
	if err != nil {
		t.Fatalf("Build() error = %v", err)
	}

	todoIndex := strings.Index(got.SystemPrompt, "## Todo State")
	systemStateIndex := strings.Index(got.SystemPrompt, "## System State")
	if todoIndex < 0 || systemStateIndex < 0 {
		t.Fatalf("expected todo and system sections, got %q", got.SystemPrompt)
	}
	if todoIndex > systemStateIndex {
		t.Fatalf("expected todo section before system section, got %q", got.SystemPrompt)
	}
}

func TestDefaultBuilderBuildPlacesRulesBeforeMemo(t *testing.T) {
	t.Parallel()

	baseDir := filepath.Join(t.TempDir(), ".neocode")
	projectRoot := t.TempDir()
	if err := os.MkdirAll(baseDir, 0o755); err != nil {
		t.Fatalf("mkdir baseDir: %v", err)
	}
	if err := os.WriteFile(filepath.Join(projectRoot, projectRuleFileName), []byte("project-rules"), 0o644); err != nil {
		t.Fatalf("write project AGENTS.md: %v", err)
	}
	if err := os.WriteFile(filepath.Join(baseDir, projectRuleFileName), []byte("global-rules"), 0o644); err != nil {
		t.Fatalf("write global AGENTS.md: %v", err)
	}

	builder := &DefaultBuilder{
		stablePromptSources: []promptSectionSource{
			corePromptSource{},
			newRulesPromptSource(rules.NewLoader(baseDir)),
			stubPromptSectionSource{sections: []promptSection{{Title: "Memo", Content: "remember this"}}},
		},
		dynamicPromptSources: []promptSectionSource{
			&systemStateSource{},
		},
	}

	got, err := builder.Build(stdcontext.Background(), BuildInput{
		Messages: []providertypes.Message{
			{Role: "user", Parts: []providertypes.ContentPart{providertypes.NewTextPart("hello")}},
		},
		Metadata: Metadata{
			ProjectRoot: projectRoot,
			Workdir:     filepath.Join(projectRoot, "subdir"),
			Shell:       "powershell",
			Provider:    "openai",
			Model:       "gpt-test",
		},
	})
	if err != nil {
		t.Fatalf("Build() error = %v", err)
	}

	rulesIndex := strings.Index(got.SystemPrompt, "## Rules")
	memoIndex := strings.Index(got.SystemPrompt, "## Memo")
	if rulesIndex < 0 || memoIndex < 0 {
		t.Fatalf("expected rules and memo sections, got %q", got.SystemPrompt)
	}
	if rulesIndex > memoIndex {
		t.Fatalf("expected rules before memo, got %q", got.SystemPrompt)
	}
	if !strings.Contains(got.SystemPrompt, "project-rules") || !strings.Contains(got.SystemPrompt, "global-rules") {
		t.Fatalf("expected both project and global rules, got %q", got.SystemPrompt)
	}
}

func TestDefaultBuilderBuildUsesSpanTrimPolicyWhenTrimPolicyIsUnset(t *testing.T) {
	t.Parallel()

	messages := make([]providertypes.Message, 0, maxRetainedMessageSpans+2)
	for i := 0; i < maxRetainedMessageSpans+2; i++ {
		messages = append(messages, providertypes.Message{
			Role:  providertypes.RoleUser,
			Parts: []providertypes.ContentPart{providertypes.NewTextPart(fmt.Sprintf("u-%d", i))},
		})
	}

	builder := &DefaultBuilder{
		stablePromptSources: []promptSectionSource{
			stubPromptSectionSource{sections: []promptSection{{Title: "Stub", Content: "body"}}},
		},
	}

	got, err := builder.Build(stdcontext.Background(), BuildInput{
		Messages:  messages,
		TaskState: agentsession.TaskState{Goal: "keep implementing task"},
		Compact:   CompactOptions{},
	})
	if err != nil {
		t.Fatalf("Build() error = %v", err)
	}
	if len(got.Messages) != maxRetainedMessageSpans {
		t.Fatalf("expected %d retained messages, got %d", maxRetainedMessageSpans, len(got.Messages))
	}
	if renderDisplayParts(got.Messages[0].Parts) != "u-2" {
		t.Fatalf("expected oldest messages to be trimmed, got first message %+v", got.Messages[0])
	}
}

func TestDefaultBuilderBuildReturnsPromptSourceError(t *testing.T) {
	t.Parallel()

	builder := &DefaultBuilder{
		stablePromptSources: []promptSectionSource{
			stubPromptSectionSource{err: fmt.Errorf("source failed")},
		},
	}

	_, err := builder.Build(stdcontext.Background(), BuildInput{})
	if err == nil || !strings.Contains(err.Error(), "source failed") {
		t.Fatalf("expected source error, got %v", err)
	}
}

func TestNewBuilder(t *testing.T) {
	t.Parallel()

	builder := NewBuilder()

	messages := []providertypes.Message{
		{Role: providertypes.RoleUser, Parts: []providertypes.ContentPart{providertypes.NewTextPart("older user")}},
		{
			Role: providertypes.RoleAssistant,
			ToolCalls: []providertypes.ToolCall{
				{ID: "call-1", Name: "filesystem_read_file", Arguments: "{}"},
			},
		},
		{Role: providertypes.RoleTool, ToolCallID: "call-1", Parts: []providertypes.ContentPart{providertypes.NewTextPart("old read result")}},
		{
			Role: providertypes.RoleAssistant,
			ToolCalls: []providertypes.ToolCall{
				{ID: "call-2", Name: "bash", Arguments: "{}"},
			},
		},
		{Role: providertypes.RoleTool, ToolCallID: "call-2", Parts: []providertypes.ContentPart{providertypes.NewTextPart("recent bash result")}},
		{
			Role: providertypes.RoleAssistant,
			ToolCalls: []providertypes.ToolCall{
				{ID: "call-3", Name: "webfetch", Arguments: "{}"},
			},
		},
		{Role: providertypes.RoleTool, ToolCallID: "call-3", Parts: []providertypes.ContentPart{providertypes.NewTextPart("latest webfetch result")}},
		{Role: providertypes.RoleUser, Parts: []providertypes.ContentPart{providertypes.NewTextPart("latest explicit instruction")}},
	}

	got, err := builder.Build(stdcontext.Background(), BuildInput{
		Messages:  messages,
		TaskState: agentsession.TaskState{Goal: "keep implementing task"},
		Compact:   CompactOptions{},
		Metadata:  testMetadata(t.TempDir()),
	})
	if err != nil {
		t.Fatalf("Build() error = %v", err)
	}
	const olderReadIndex = 2
	if renderDisplayParts(got.Messages[olderReadIndex].Parts) != "old read result" {
		t.Fatalf(
			"expected older read result content, got %q",
			renderDisplayParts(got.Messages[olderReadIndex].Parts),
		)
	}
}

func TestTrimMessagesPreservesToolPairs(t *testing.T) {
	t.Parallel()

	messages := make([]providertypes.Message, 0, maxRetainedMessageSpans+4)
	for i := 0; i < 8; i++ {
		messages = append(messages, providertypes.Message{Role: "user", Parts: []providertypes.ContentPart{providertypes.NewTextPart(fmt.Sprintf("u-%d", i))}})
	}
	messages = append(messages,
		providertypes.Message{
			Role: "assistant",
			ToolCalls: []providertypes.ToolCall{
				{ID: "call-1", Name: "filesystem_edit", Arguments: "{}"},
			},
		},
		providertypes.Message{Role: "tool", ToolCallID: "call-1", Parts: []providertypes.ContentPart{providertypes.NewTextPart("tool-result")}},
		providertypes.Message{Role: "assistant", Parts: []providertypes.ContentPart{providertypes.NewTextPart("after-tool")}},
		providertypes.Message{Role: "user", Parts: []providertypes.ContentPart{providertypes.NewTextPart("latest")}},
	)

	trimmed := trimMessages(messages, maxRetainedMessageSpans)
	if len(trimmed) > len(messages) {
		t.Fatalf("trimmed messages should not grow")
	}

	foundAssistantToolCall := false
	foundToolResult := false
	for _, message := range trimmed {
		if message.Role == "assistant" && len(message.ToolCalls) > 0 {
			foundAssistantToolCall = true
		}
		if message.Role == "tool" && message.ToolCallID == "call-1" {
			foundToolResult = true
		}
	}
	if foundAssistantToolCall != foundToolResult {
		t.Fatalf("expected tool call and tool result to be preserved together, got %+v", trimmed)
	}
}

func TestTrimMessagesProtectsLatestExplicitUserInstructionTail(t *testing.T) {
	t.Parallel()

	const retainedSpans = 10

	messages := make([]providertypes.Message, 0, maxRetainedMessageSpans+5)
	for i := 0; i < 2; i++ {
		messages = append(messages, providertypes.Message{Role: providertypes.RoleUser, Parts: []providertypes.ContentPart{providertypes.NewTextPart(fmt.Sprintf("old-%d", i))}})
	}
	messages = append(messages,
		providertypes.Message{Role: providertypes.RoleUser, Parts: []providertypes.ContentPart{providertypes.NewTextPart("latest explicit instruction")}},
		providertypes.Message{Role: providertypes.RoleAssistant, Parts: []providertypes.ContentPart{providertypes.NewTextPart("follow-up-1")}},
		providertypes.Message{Role: providertypes.RoleAssistant, Parts: []providertypes.ContentPart{providertypes.NewTextPart("follow-up-2")}},
		providertypes.Message{Role: providertypes.RoleAssistant, Parts: []providertypes.ContentPart{providertypes.NewTextPart("follow-up-3")}},
		providertypes.Message{Role: providertypes.RoleAssistant, Parts: []providertypes.ContentPart{providertypes.NewTextPart("follow-up-4")}},
		providertypes.Message{Role: providertypes.RoleAssistant, Parts: []providertypes.ContentPart{providertypes.NewTextPart("follow-up-5")}},
		providertypes.Message{Role: providertypes.RoleAssistant, Parts: []providertypes.ContentPart{providertypes.NewTextPart("follow-up-6")}},
		providertypes.Message{Role: providertypes.RoleAssistant, Parts: []providertypes.ContentPart{providertypes.NewTextPart("follow-up-7")}},
		providertypes.Message{Role: providertypes.RoleAssistant, Parts: []providertypes.ContentPart{providertypes.NewTextPart("follow-up-8")}},
		providertypes.Message{Role: providertypes.RoleAssistant, Parts: []providertypes.ContentPart{providertypes.NewTextPart("follow-up-9")}},
		providertypes.Message{Role: providertypes.RoleAssistant, Parts: []providertypes.ContentPart{providertypes.NewTextPart("follow-up-10")}},
		providertypes.Message{Role: providertypes.RoleAssistant, Parts: []providertypes.ContentPart{providertypes.NewTextPart("follow-up-11")}},
	)

	trimmed := trimMessages(messages, retainedSpans)
	if trimmed[0].Role != providertypes.RoleUser || renderDisplayParts(trimmed[0].Parts) != "latest explicit instruction" {
		t.Fatalf("expected protected tail to keep latest explicit user instruction, got %+v", trimmed[0])
	}
	if len(trimmed) != 12 {
		t.Fatalf("expected protected tail to keep latest instruction and full assistant tail, got %d messages", len(trimmed))
	}
}

func TestTrimMessagesUsesSharedSpanModel(t *testing.T) {
	t.Parallel()

	const retainedSpans = 10

	messages := make([]providertypes.Message, 0, maxRetainedMessageSpans+6)
	for i := 0; i < 3; i++ {
		messages = append(messages, providertypes.Message{Role: providertypes.RoleUser, Parts: []providertypes.ContentPart{providertypes.NewTextPart(fmt.Sprintf("u-%d", i))}})
	}
	messages = append(messages,
		providertypes.Message{
			Role: providertypes.RoleAssistant,
			ToolCalls: []providertypes.ToolCall{
				{ID: "call-2", Name: "filesystem_read_file", Arguments: "{}"},
			},
		},
		providertypes.Message{Role: providertypes.RoleTool, ToolCallID: "call-2", Parts: []providertypes.ContentPart{providertypes.NewTextPart("tool-result")}},
		providertypes.Message{Role: providertypes.RoleAssistant, Parts: []providertypes.ContentPart{providertypes.NewTextPart("after tool")}},
		providertypes.Message{Role: providertypes.RoleUser, Parts: []providertypes.ContentPart{providertypes.NewTextPart("u-4")}},
		providertypes.Message{Role: providertypes.RoleAssistant, Parts: []providertypes.ContentPart{providertypes.NewTextPart("a-5")}},
		providertypes.Message{Role: providertypes.RoleUser, Parts: []providertypes.ContentPart{providertypes.NewTextPart("u-6")}},
		providertypes.Message{Role: providertypes.RoleAssistant, Parts: []providertypes.ContentPart{providertypes.NewTextPart("a-7")}},
		providertypes.Message{Role: providertypes.RoleUser, Parts: []providertypes.ContentPart{providertypes.NewTextPart("u-8")}},
		providertypes.Message{Role: providertypes.RoleAssistant, Parts: []providertypes.ContentPart{providertypes.NewTextPart("a-9")}},
		providertypes.Message{Role: providertypes.RoleUser, Parts: []providertypes.ContentPart{providertypes.NewTextPart("u-10")}},
		providertypes.Message{Role: providertypes.RoleAssistant, Parts: []providertypes.ContentPart{providertypes.NewTextPart("a-11")}},
	)

	spans := internalcompact.BuildMessageSpans(messages)
	trimmed := trimMessages(messages, retainedSpans)

	start := spans[len(spans)-retainedSpans].Start
	if len(trimmed) == 0 || renderDisplayParts(trimmed[0].Parts) != renderDisplayParts(messages[start].Parts) {
		t.Fatalf("expected trim to start from shared span boundary %d, got %+v", start, trimmed)
	}
	if trimmed[0].Role != providertypes.RoleAssistant || len(trimmed[0].ToolCalls) != 1 {
		t.Fatalf("expected trim to keep whole tool block at shared boundary, got %+v", trimmed[0])
	}
}

func TestTrimMessagesBoundaries(t *testing.T) {
	t.Parallel()

	tests := []struct {
		name    string
		input   []providertypes.Message
		wantLen int
		assert  func(t *testing.T, original []providertypes.Message, trimmed []providertypes.Message)
	}{
		{
			name: "within max turns returns full cloned slice",
			input: []providertypes.Message{
				{Role: "user", Parts: []providertypes.ContentPart{providertypes.NewTextPart("one")}},
				{Role: "assistant", Parts: []providertypes.ContentPart{providertypes.NewTextPart("two")}},
			},
			wantLen: 2,
			assert: func(t *testing.T, original []providertypes.Message, trimmed []providertypes.Message) {
				t.Helper()
				if &trimmed[0] == &original[0] {
					t.Fatalf("expected trimmed slice to be cloned")
				}
			},
		},
		{
			name: "long message list with limited spans keeps full history",
			input: func() []providertypes.Message {
				messages := make([]providertypes.Message, 0, maxRetainedMessageSpans+3)
				for i := 0; i < maxRetainedMessageSpans-1; i++ {
					messages = append(messages, providertypes.Message{Role: "user", Parts: []providertypes.ContentPart{providertypes.NewTextPart(fmt.Sprintf("u-%d", i))}})
				}
				messages = append(messages,
					providertypes.Message{
						Role: "assistant",
						ToolCalls: []providertypes.ToolCall{
							{ID: "call-1", Name: "filesystem_edit", Arguments: "{}"},
						},
					},
					providertypes.Message{Role: "tool", ToolCallID: "call-1", Parts: []providertypes.ContentPart{providertypes.NewTextPart("tool-1")}},
					providertypes.Message{Role: "tool", ToolCallID: "call-1", Parts: []providertypes.ContentPart{providertypes.NewTextPart("tool-2")}},
				)
				return messages
			}(),
			wantLen: maxRetainedMessageSpans + 2,
			assert: func(t *testing.T, original []providertypes.Message, trimmed []providertypes.Message) {
				t.Helper()
				if len(trimmed) != len(original) {
					t.Fatalf("expected full history to remain, got %d want %d", len(trimmed), len(original))
				}
			},
		},
		{
			name: "message count beyond limit trims by span count",
			input: func() []providertypes.Message {
				messages := make([]providertypes.Message, 0, maxRetainedMessageSpans+5)
				for i := 0; i < maxRetainedMessageSpans+1; i++ {
					messages = append(messages, providertypes.Message{Role: "user", Parts: []providertypes.ContentPart{providertypes.NewTextPart(fmt.Sprintf("u-%d", i))}})
				}
				messages = append(messages,
					providertypes.Message{
						Role: "assistant",
						ToolCalls: []providertypes.ToolCall{
							{ID: "call-2", Name: "filesystem_edit", Arguments: "{}"},
						},
					},
					providertypes.Message{Role: "tool", ToolCallID: "call-2", Parts: []providertypes.ContentPart{providertypes.NewTextPart("tool-result")}},
				)
				return messages
			}(),
			wantLen: maxRetainedMessageSpans + 1,
			assert: func(t *testing.T, original []providertypes.Message, trimmed []providertypes.Message) {
				t.Helper()
				if renderDisplayParts(trimmed[0].Parts) != "u-2" {
					t.Fatalf("expected oldest spans to be removed, got first message %+v", trimmed[0])
				}
				if trimmed[len(trimmed)-1].Role != "tool" {
					t.Fatalf("expected trailing tool result to remain, got %+v", trimmed[len(trimmed)-1])
				}
			},
		},
	}

	for _, tt := range tests {
		tt := tt
		t.Run(tt.name, func(t *testing.T) {
			trimmed := trimMessages(tt.input, maxRetainedMessageSpans)
			if len(trimmed) != tt.wantLen {
				t.Fatalf("expected len %d, got %d", tt.wantLen, len(trimmed))
			}
			if tt.assert != nil {
				tt.assert(t, tt.input, trimmed)
			}
		})
	}
}

func TestNewConfiguredBuilder(t *testing.T) {
	t.Parallel()

	t.Run("empty config defaults pin checker", func(t *testing.T) {
		builder := NewConfiguredBuilder()
		input := BuildInput{
			Messages: []providertypes.Message{{Role: "user", Parts: []providertypes.ContentPart{providertypes.NewTextPart("hello")}}},
			Metadata: testMetadata(t.TempDir()),
		}
		result, err := builder.Build(stdcontext.Background(), input)
		if err != nil {
			t.Fatalf("Build() error = %v", err)
		}
		if result.SystemPrompt == "" {
			t.Fatalf("expected non-empty system prompt")
		}
	})

	t.Run("with extra section sources", func(t *testing.T) {
		extraSource := stubPromptSectionSource{
			sections: []promptSection{{Title: "Custom", Content: "custom section body"}},
		}
		builder := NewConfiguredBuilder(extraSource)
		input := BuildInput{
			Messages: []providertypes.Message{{Role: "user", Parts: []providertypes.ContentPart{providertypes.NewTextPart("hello")}}},
			Metadata: testMetadata(t.TempDir()),
		}
		result, err := builder.Build(stdcontext.Background(), input)
		if err != nil {
			t.Fatalf("Build() error = %v", err)
		}
		if !strings.Contains(result.SystemPrompt, "## Custom") {
			t.Errorf("expected Custom section in system prompt")
		}
		if !strings.Contains(result.SystemPrompt, "custom section body") {
			t.Errorf("expected custom section content in system prompt")
		}
	})

	t.Run("multiple extra section sources are appended", func(t *testing.T) {
		builder := NewConfiguredBuilder(stubPromptSectionSource{
			sections: []promptSection{{Title: "First", Content: "first body"}},
		}, stubPromptSectionSource{
			sections: []promptSection{{Title: "Extra", Content: "extra body"}},
		})
		input := BuildInput{
			Messages: []providertypes.Message{{Role: "user", Parts: []providertypes.ContentPart{providertypes.NewTextPart("hello")}}},
			Metadata: testMetadata(t.TempDir()),
		}
		result, err := builder.Build(stdcontext.Background(), input)
		if err != nil {
			t.Fatalf("Build() error = %v", err)
		}
		if !strings.Contains(result.SystemPrompt, "## Extra") {
			t.Errorf("expected Extra section in system prompt")
		}
		if !strings.Contains(result.SystemPrompt, "## First") {
			t.Errorf("expected First section in system prompt")
		}
	})
}

func TestProjectToolMessagesForModelKeepsBuilderProjectionBehavior(t *testing.T) {
	t.Parallel()

	messages := []providertypes.Message{
		{
			Role:         providertypes.RoleTool,
			ToolCallID:   "call-1",
			Parts:        []providertypes.ContentPart{providertypes.NewTextPart("tool output")},
			ToolMetadata: map[string]string{"tool_name": "filesystem_read_file", "path": "README.md"},
		},
	}

	projected := ProjectToolMessagesForModel(cloneContextMessages(messages))
	if len(projected) != 1 {
		t.Fatalf("len(projected) = %d, want 1", len(projected))
	}
	projectedText := renderDisplayParts(projected[0].Parts)
	if !strings.Contains(projectedText, "tool result") || !strings.Contains(projectedText, "tool: filesystem_read_file") {
		t.Fatalf("unexpected projected content: %q", projectedText)
	}
	if projected[0].ToolMetadata != nil {
		t.Fatalf("expected projected metadata to be cleared, got %#v", projected[0].ToolMetadata)
	}
	if messages[0].ToolMetadata == nil {
		t.Fatal("expected source messages to remain unchanged")
	}
}

func TestDefaultBuilderBuildProjectsMetadataOnlyToolResult(t *testing.T) {
	t.Parallel()

	builder := NewBuilder()
	result, err := builder.Build(stdcontext.Background(), BuildInput{
		Messages: []providertypes.Message{
			{Role: providertypes.RoleUser, Parts: []providertypes.ContentPart{providertypes.NewTextPart("inspect README")}},
			{
				Role: providertypes.RoleAssistant,
				ToolCalls: []providertypes.ToolCall{
					{ID: "call-1", Name: "filesystem_read_file", Arguments: `{"path":"README.md"}`},
				},
			},
			{
				Role:         providertypes.RoleTool,
				ToolCallID:   "call-1",
				Parts:        []providertypes.ContentPart{providertypes.NewTextPart("   ")},
				ToolMetadata: map[string]string{"tool_name": "filesystem_read_file", "path": "README.md"},
			},
		},
		Metadata: testMetadata(t.TempDir()),
	})
	if err != nil {
		t.Fatalf("Build() error = %v", err)
	}
	if len(result.Messages) != 3 {
		t.Fatalf("len(result.Messages) = %d, want 3", len(result.Messages))
	}
	toolMessage := result.Messages[2]
	if toolMessage.Role != providertypes.RoleTool {
		t.Fatalf("expected tool message at index 2, got %+v", toolMessage)
	}
	toolMessageText := renderDisplayParts(toolMessage.Parts)
	if !strings.Contains(toolMessageText, "tool result") ||
		!strings.Contains(toolMessageText, "tool: filesystem_read_file") ||
		!strings.Contains(toolMessageText, "meta.path: README.md") {
		t.Fatalf("expected metadata-only tool result to be projected, got %q", toolMessageText)
	}
	if toolMessage.ToolMetadata != nil {
		t.Fatalf("expected projected tool metadata to be cleared, got %#v", toolMessage.ToolMetadata)
	}
}

func TestDefaultBuilderBuildBoundsProjectedToolContentWithoutMutatingInput(t *testing.T) {
	t.Parallel()

	head := strings.Repeat("A", recentWindowToolContentHeadChars)
	middle := strings.Repeat("M", 64)
	tail := strings.Repeat("B", recentWindowToolContentTailChars-len("TAIL-MARKER")) + "TAIL-MARKER"
	rawBody := head + middle + tail
	originalMetadata := map[string]string{"tool_name": "bash", "workdir": "D:/project"}
	messages := []providertypes.Message{
		{Role: providertypes.RoleUser, Parts: []providertypes.ContentPart{providertypes.NewTextPart("run command")}},
		{
			Role: providertypes.RoleAssistant,
			ToolCalls: []providertypes.ToolCall{
				{ID: "call-1", Name: "bash", Arguments: `{}`},
			},
		},
		{
			Role:         providertypes.RoleTool,
			ToolCallID:   "call-1",
			Parts:        []providertypes.ContentPart{providertypes.NewTextPart(rawBody)},
			ToolMetadata: originalMetadata,
		},
	}

	result, err := NewBuilder().Build(stdcontext.Background(), BuildInput{
		Messages: messages,
		Metadata: testMetadata(t.TempDir()),
	})
	if err != nil {
		t.Fatalf("Build() error = %v", err)
	}

	projectedText := renderDisplayParts(result.Messages[2].Parts)
	if !strings.Contains(projectedText, "tool result") ||
		!strings.Contains(projectedText, "tool: bash") ||
		!strings.Contains(projectedText, "content_excerpt:") {
		t.Fatalf("expected structured excerpted tool result, got %q", projectedText)
	}
	if strings.Contains(projectedText, "\ncontent:\n") {
		t.Fatalf("expected full content marker to be removed, got %q", projectedText)
	}
	if strings.Contains(projectedText, middle) {
		t.Fatalf("expected middle payload to be truncated, got %q", projectedText)
	}
	if !strings.Contains(projectedText, truncatedExcerptMarker) ||
		!strings.Contains(projectedText, "TAIL-MARKER") ||
		!strings.Contains(projectedText, contentTruncatedForModelContext) {
		t.Fatalf("expected head/tail truncation markers, got %q", projectedText)
	}
	if result.Messages[2].ToolMetadata != nil {
		t.Fatalf("expected projected metadata to be cleared, got %#v", result.Messages[2].ToolMetadata)
	}
	if renderDisplayParts(messages[2].Parts) != rawBody {
		t.Fatalf("expected source tool content unchanged, got %q", renderDisplayParts(messages[2].Parts))
	}
	if messages[2].ToolMetadata["tool_name"] != "bash" || messages[2].ToolMetadata["workdir"] != "D:/project" {
		t.Fatalf("expected source tool metadata unchanged, got %#v", messages[2].ToolMetadata)
	}
}

func TestDefaultBuilderBuildReturnsStableAndDynamicPrompts(t *testing.T) {
	t.Parallel()

	builder := NewBuilder()
	result, err := builder.Build(stdcontext.Background(), BuildInput{
		Messages: []providertypes.Message{
			{Role: "user", Parts: []providertypes.ContentPart{providertypes.NewTextPart("hello")}},
		},
		Metadata: testMetadata(t.TempDir()),
	})
	if err != nil {
		t.Fatalf("Build() error = %v", err)
	}

	if result.StableSystemPrompt == "" {
		t.Fatalf("expected non-empty StableSystemPrompt")
	}
	if result.DynamicSystemPrompt == "" {
		t.Fatalf("expected non-empty DynamicSystemPrompt")
	}

	if !strings.Contains(result.StableSystemPrompt, "## Agent Identity") {
		t.Fatalf("expected Agent Identity in stable prompt, got %q", result.StableSystemPrompt)
	}
	if !strings.Contains(result.StableSystemPrompt, "## Tool Usage") {
		t.Fatalf("expected Tool Usage in stable prompt, got %q", result.StableSystemPrompt)
	}
	if !strings.Contains(result.DynamicSystemPrompt, "## Capabilities & Limitations") {
		t.Fatalf("expected Capabilities & Limitations in dynamic prompt, got %q", result.DynamicSystemPrompt)
	}
	if !strings.Contains(result.DynamicSystemPrompt, "## System State") {
		t.Fatalf("expected System State in dynamic prompt, got %q", result.DynamicSystemPrompt)
	}

	expected := result.StableSystemPrompt + "\n\n" + result.DynamicSystemPrompt
	if result.SystemPrompt != expected {
		t.Fatalf("SystemPrompt should equal StableSystemPrompt + DynamicSystemPrompt, got %q, expected %q", result.SystemPrompt, expected)
	}
}
func TestDefaultBuilderBuildTodoChangeDoesNotChangeStablePrompt(t *testing.T) {
	t.Parallel()

	builder := NewBuilder()
	baseInput := BuildInput{
		Messages: []providertypes.Message{
			{Role: "user", Parts: []providertypes.ContentPart{providertypes.NewTextPart("hello")}},
		},
		Metadata: testMetadata(t.TempDir()),
	}

	first, err := builder.Build(stdcontext.Background(), baseInput)
	if err != nil {
		t.Fatalf("first Build() error = %v", err)
	}

	inputWithTodos := baseInput
	inputWithTodos.Todos = []agentsession.TodoItem{
		{
			ID:      "todo-1",
			Content: "new todo",
			Status:  agentsession.TodoStatusPending,
		},
	}
	second, err := builder.Build(stdcontext.Background(), inputWithTodos)
	if err != nil {
		t.Fatalf("second Build() error = %v", err)
	}

	if first.StableSystemPrompt != second.StableSystemPrompt {
		t.Fatalf("expected StableSystemPrompt unchanged after todo change")
	}
	if first.DynamicSystemPrompt == second.DynamicSystemPrompt {
		t.Fatalf("expected DynamicSystemPrompt to change after todo change")
	}
}

func TestDefaultBuilderBuildMemoIsStable(t *testing.T) {
	t.Parallel()

	builder := NewConfiguredBuilder(stubPromptSectionSource{
		sections: []promptSection{
			NewPromptSection("memo", "remember this"),
		},
	})

	result, err := builder.Build(stdcontext.Background(), BuildInput{
		Messages: []providertypes.Message{
			{Role: "user", Parts: []providertypes.ContentPart{providertypes.NewTextPart("hello")}},
		},
		Metadata: testMetadata(t.TempDir()),
	})
	if err != nil {
		t.Fatalf("Build() error = %v", err)
	}

	if !strings.Contains(result.StableSystemPrompt, "## memo") {
		t.Fatalf("expected memo in StableSystemPrompt, got %q", result.StableSystemPrompt)
	}
	if strings.Contains(result.DynamicSystemPrompt, "## memo") {
		t.Fatalf("did not expect memo in DynamicSystemPrompt, got %q", result.DynamicSystemPrompt)
	}
}

func TestDefaultBuilderBuildStableAndDynamicFields(t *testing.T) {
	t.Parallel()

	builder := &DefaultBuilder{
		stablePromptSources: []promptSectionSource{
			stubPromptSectionSource{sections: []promptSection{{Title: "Stable", Content: "stable style"}}},
		},
		dynamicPromptSources: []promptSectionSource{
			stubPromptSectionSource{sections: []promptSection{{Title: "Dynamic", Content: "dynamic style"}}},
		},
		trimPolicy: spanMessageTrimPolicy{},
	}

	result, err := builder.Build(stdcontext.Background(), BuildInput{})
	if err != nil {
		t.Fatalf("Build() error = %v", err)
	}
	if !strings.Contains(result.SystemPrompt, "stable style") || !strings.Contains(result.SystemPrompt, "dynamic style") {
		t.Fatalf("expected stable and dynamic content in system prompt, got %q", result.SystemPrompt)
	}
	if !strings.Contains(result.StableSystemPrompt, "stable style") {
		t.Fatalf("expected stable content in StableSystemPrompt, got %q", result.StableSystemPrompt)
	}
	if !strings.Contains(result.DynamicSystemPrompt, "dynamic style") {
		t.Fatalf("expected dynamic content in DynamicSystemPrompt, got %q", result.DynamicSystemPrompt)
	}
}