package leaderloop

import (
	"context"
	"encoding/json"
	"os"
	"path/filepath"
	"strings"
	"testing"
	"time"

	"inbox/internal/app/runtimecodex"
	"inbox/internal/app/runtimeconfig"
	"inbox/internal/app/workspaceruntime"
	"inbox/internal/base/timeutil"
	"inbox/internal/domain/lane"
	"inbox/internal/domain/message"
	"inbox/internal/domain/role"
	"inbox/internal/domain/task"
	"inbox/internal/domain/topic"
	"inbox/internal/domain/workflow"
	"inbox/internal/domain/workspace"
	sqlitestore "inbox/internal/store/sqlite"
)

func TestProcessOnceConsumesLeaderMessageAndCreatesLaneTasks(t *testing.T) {
	ctx := context.Background()
	clock := timeutil.FixedClock{Time: time.Date(2026, 3, 17, 4, 0, 0, 0, time.UTC)}
	store, err := sqlitestore.OpenInMemory(clock)
	if err != nil {
		t.Fatalf("OpenInMemory() error = %v", err)
	}
	defer store.Close()

	ws, topicRecord := seedLeaderLoopWorkspace(t, ctx, store, clock)
	if _, err := store.CreateMessage(ctx, message.Record{
		WorkspaceID:  ws.ID,
		TopicID:      topicRecord.ID,
		FromRoleName: "user",
		ToExpr:       "leader",
		Type:         message.TypeChat,
		Stage:        "plan",
		BodyMarkdown: "Build a todo app.",
	}); err != nil {
		t.Fatalf("CreateMessage() error = %v", err)
	}

	fakeRuntime := &fakeWorkspaceRuntime{workspace: ws}
	runner := &fakeRunner{result: RunResult{
		Status: workflow.RunStatusSucceeded,
		ResultJSON: `{
				"plan_summary_markdown":"Leader created the first execution lane.",
				"plan_mode":"initial",
				"execution_mode":"plan_only",
				"leader_reply":{"markdown":"I split the work into a UI graph and will wait for confirmation.","type":"chat"},
				"tasks":[
					{"key":"design","title":"Design the UI","body_markdown":"Create the React UI.","acceptance_markdown":"UI is polished.","kind":"execution","deliverables":["apps/web/src"],"priority":10,"task_order":1,"depends_on":[]},
					{"key":"verify","title":"Verify the UI","body_markdown":"Verify the UI flow.","acceptance_markdown":"Verification complete.","kind":"verification","deliverables":["reports/ui-check.md"],"priority":5,"task_order":2,"depends_on":["design"]}
				]
			}`,
	}}
	service := NewService(
		store,
		runtimeconfig.NewService(store, store, clock),
		fakeRuntime,
		runner,
		clock,
		"",
	)

	result, err := service.ProcessOnce(ctx)
	if err != nil {
		t.Fatalf("ProcessOnce() error = %v", err)
	}
	if result == nil {
		t.Fatal("expected leader result")
	}
	if len(result.Lanes) != 1 || result.Lanes[0].Name != "Design the UI" {
		t.Fatalf("unexpected lanes: %#v", result.Lanes)
	}
	if len(result.Tasks) != 2 {
		t.Fatalf("unexpected tasks: %#v", result.Tasks)
	}
	if fakeRuntime.startedLaneID != "" {
		t.Fatalf("expected initial graph to wait for confirmation, got started lane %q", fakeRuntime.startedLaneID)
	}
	if result.Reply == nil || result.Reply.ToExpr != "user" {
		t.Fatalf("expected reply to user, got %#v", result.Reply)
	}
	if !strings.Contains(runner.prompt, "## Skills") || !strings.Contains(runner.prompt, "Use Inbox V2") {
		t.Fatalf("expected leader prompt to include bound skills, got %q", runner.prompt)
	}
	if !strings.Contains(result.Run.CommandJSON, `"planning"`) || !strings.Contains(result.Run.CommandJSON, `"execution_mode":"plan_only"`) {
		t.Fatalf("expected planning payload in command_json, got %s", result.Run.CommandJSON)
	}

	tasks, err := store.ListTasksByTopic(ctx, topicRecord.ID)
	if err != nil {
		t.Fatalf("ListTasksByTopic() error = %v", err)
	}
	if len(tasks) != 2 {
		t.Fatalf("expected 2 tasks in store, got %d", len(tasks))
	}
	if tasks[0].Status != task.StatusReady || tasks[1].Status != task.StatusDraft {
		t.Fatalf("unexpected task statuses: %#v", tasks)
	}
	updatedTopic, err := store.GetTopic(ctx, topicRecord.ID)
	if err != nil {
		t.Fatalf("GetTopic() error = %v", err)
	}
	if updatedTopic.Status != "awaiting_confirmation" {
		t.Fatalf("expected awaiting_confirmation topic, got %#v", updatedTopic)
	}
	graphVersion, err := store.GetLatestTaskGraphVersionByTopic(ctx, topicRecord.ID)
	if err != nil {
		t.Fatalf("GetLatestTaskGraphVersionByTopic() error = %v", err)
	}
	if graphVersion.Status != "draft" {
		t.Fatalf("expected draft graph version, got %#v", graphVersion)
	}
}

func TestParseLeaderOutputRejectsInitialFreezeStartNodes(t *testing.T) {
	_, err := parseLeaderOutput(`{
		"plan_summary_markdown":"Draft the initial graph.",
		"plan_mode":"initial",
		"execution_mode":"plan_only",
				"leader_reply":{"markdown":"Please confirm the graph first.","type":"summary"},
				"tasks":[
					{"key":"build","title":"Build app","body_markdown":"Implement app.","acceptance_markdown":"App works.","kind":"execution","deliverables":["apps/web"],"priority":1,"task_order":1,"depends_on":[]}
				],
				"start_nodes":["app"]
		}`, true)
	if err == nil || !strings.Contains(err.Error(), `unknown field "start_nodes"`) {
		t.Fatalf("expected initial freeze start_nodes error, got %v", err)
	}
}

func TestLeaderOutputSchemaRequiresEveryDeclaredProperty(t *testing.T) {
	for _, initialFreeze := range []bool{true, false} {
		schemaJSON := leaderOutputSchema(initialFreeze)
		var schema map[string]any
		if err := json.Unmarshal([]byte(schemaJSON), &schema); err != nil {
			t.Fatalf("json.Unmarshal(schema) error = %v", err)
		}

		assertSchemaRequiredMatchesProperties(t, schema)

		properties := schema["properties"].(map[string]any)
		tasks := properties["tasks"].(map[string]any)
		items := tasks["items"].(map[string]any)
		assertSchemaRequiredMatchesProperties(t, items)

		leaderReply := properties["leader_reply"].(map[string]any)
		assertSchemaRequiredMatchesProperties(t, leaderReply)
	}
}

func TestProcessOnceReusesExistingLaneOnWorkerFollowUp(t *testing.T) {
	ctx := context.Background()
	clock := timeutil.FixedClock{Time: time.Date(2026, 3, 17, 4, 30, 0, 0, time.UTC)}
	store, err := sqlitestore.OpenInMemory(clock)
	if err != nil {
		t.Fatalf("OpenInMemory() error = %v", err)
	}
	defer store.Close()

	ws, topicRecord := seedLeaderLoopWorkspace(t, ctx, store, clock)
	_, err = store.CreateLane(ctx, lane.Record{
		WorkspaceID:       ws.ID,
		TopicID:           topicRecord.ID,
		Name:              "UI Chain",
		Slug:              "ui-chain",
		Status:            lane.StatusBlocked,
		CreatedByRoleName: "leader",
	})
	if err != nil {
		t.Fatalf("CreateLane() error = %v", err)
	}
	if _, err := store.CreateMessage(ctx, message.Record{
		WorkspaceID:  ws.ID,
		TopicID:      topicRecord.ID,
		FromRoleName: "worker",
		ToExpr:       "leader",
		Type:         message.TypeSummary,
		Stage:        "execution",
		BodyMarkdown: "UI chain failed the first task.",
	}); err != nil {
		t.Fatalf("CreateMessage() error = %v", err)
	}

	fakeRuntime := &fakeWorkspaceRuntime{workspace: ws}
	service := NewService(
		store,
		runtimeconfig.NewService(store, store, clock),
		fakeRuntime,
		&fakeRunner{result: RunResult{
			Status: workflow.RunStatusSucceeded,
			ResultJSON: `{
				"plan_summary_markdown":"Reused the UI chain and queued a retry task.",
				"plan_mode":"patch",
				"replan_reason":"UI chain failed and needs a focused retry.",
				"execution_mode":"plan_and_start",
				"leader_reply":{"markdown":"继续在现有图上修复。","type":"decision"},
				"tasks":[
					{"key":"retry-ui","title":"修复 UI 初始化失败","body_markdown":"在现有 UI 图上修复失败原因。","acceptance_markdown":"UI graph 恢复可执行。","kind":"execution","deliverables":["apps/web/src"],"priority":10,"task_order":3,"depends_on":[]}
				]
			}`,
		}},
		clock,
		"",
	)

	result, err := service.ProcessOnce(ctx)
	if err != nil {
		t.Fatalf("ProcessOnce() error = %v", err)
	}
	if result == nil {
		t.Fatal("expected leader result")
	}
	if fakeRuntime.startedLaneID == "" {
		t.Fatalf("expected a derived lane to be started, got none")
	}
	lanes, err := store.ListLanesByTopic(ctx, topicRecord.ID)
	if err != nil {
		t.Fatalf("ListLanesByTopic() error = %v", err)
	}
	if len(lanes) != 2 {
		t.Fatalf("expected existing blocked lane plus one derived execution lane, got %#v", lanes)
	}
	tasks, err := store.ListTasksByTopic(ctx, topicRecord.ID)
	if err != nil {
		t.Fatalf("ListTasksByTopic() error = %v", err)
	}
	if len(tasks) != 1 {
		t.Fatalf("expected retry task on existing chain, got %#v", tasks)
	}
}

func TestParseLeaderOutputRejectsInvalidPlanOnlyStartNodes(t *testing.T) {
	_, err := parseLeaderOutput(`{
		"plan_summary_markdown":"Planned only.",
		"plan_mode":"initial",
		"execution_mode":"plan_only",
		"leader_reply":{"markdown":"先只输出计划。","type":"summary"},
		"tasks":[
			{"key":"design","title":"Design the UI","body_markdown":"Create the React UI.","acceptance_markdown":"UI is polished.","kind":"execution","deliverables":["apps/web/src"],"priority":10,"task_order":1,"depends_on":[]}
		],
		"start_nodes":["ui"]
			}`, false)
	if err == nil || !strings.Contains(err.Error(), `unknown field "start_nodes"`) {
		t.Fatalf("expected invalid plan_only start_nodes error, got %v", err)
	}
}

func TestParseLeaderOutputRejectsMissingDeliverables(t *testing.T) {
	_, err := parseLeaderOutput(`{
		"plan_summary_markdown":"Plan.",
		"plan_mode":"initial",
		"execution_mode":"plan_and_start",
		"leader_reply":{"markdown":"开始执行。","type":"decision"},
		"tasks":[
			{"key":"design","title":"Design the UI","body_markdown":"Create the React UI.","acceptance_markdown":"UI is polished.","kind":"execution","deliverables":[],"priority":10,"task_order":1,"depends_on":[]}
		]
			}`, false)
	if err == nil || !strings.Contains(err.Error(), "must declare deliverables") {
		t.Fatalf("expected missing deliverables error, got %v", err)
	}
}

func TestParseLeaderOutputRejectsDuplicateTaskKeys(t *testing.T) {
	_, err := parseLeaderOutput(`{
		"plan_summary_markdown":"Plan.",
		"plan_mode":"initial",
		"execution_mode":"plan_only",
		"leader_reply":{"markdown":"先看计划。","type":"summary"},
		"tasks":[
			{"key":"ui","title":"Build UI","body_markdown":"Create the React UI.","acceptance_markdown":"UI is polished.","kind":"execution","deliverables":["apps/web/src"],"depends_on":[]},
			{"key":"ui","title":"Verify UI","body_markdown":"Verify the React UI.","acceptance_markdown":"Verification complete.","kind":"verification","deliverables":["reports/ui-check.md"],"depends_on":["ui"]}
		]
			}`, true)
	if err == nil || !strings.Contains(err.Error(), `must be unique`) {
		t.Fatalf("expected duplicate task key error, got %v", err)
	}
}

func TestParseLeaderOutputAllowsMilestoneWithoutDeliverables(t *testing.T) {
	output, err := parseLeaderOutput(`{
		"plan_summary_markdown":"Plan with milestone.",
		"plan_mode":"initial",
		"execution_mode":"plan_only",
		"leader_reply":{"markdown":"先看计划。","type":"summary"},
		"tasks":[
			{"key":"ui","title":"Build UI","body_markdown":"Build the UI.","acceptance_markdown":"UI works.","kind":"execution","deliverables":["apps/web/src"],"priority":10,"task_order":1,"depends_on":[]},
			{"key":"ready-for-demo","title":"Ready for Demo","body_markdown":"Aggregate completion.","acceptance_markdown":"Milestone reached.","kind":"milestone","priority":5,"task_order":2,"depends_on":["ui"]}
		]
			}`, true)
	if err != nil {
		t.Fatalf("parseLeaderOutput() error = %v", err)
	}
	if len(output.Tasks) != 2 || output.Tasks[1].Kind != "milestone" {
		t.Fatalf("expected milestone task, got %#v", output.Tasks)
	}
}

func TestProcessOnceKeepsMilestoneOnExecutionLane(t *testing.T) {
	ctx := context.Background()
	clock := timeutil.FixedClock{Time: time.Date(2026, 3, 17, 4, 45, 0, 0, time.UTC)}
	store, err := sqlitestore.OpenInMemory(clock)
	if err != nil {
		t.Fatalf("OpenInMemory() error = %v", err)
	}
	defer store.Close()

	ws, topicRecord := seedLeaderLoopWorkspace(t, ctx, store, clock)
	if _, err := store.CreateMessage(ctx, message.Record{
		WorkspaceID:  ws.ID,
		TopicID:      topicRecord.ID,
		FromRoleName: "user",
		ToExpr:       "leader",
		Type:         message.TypeChat,
		Stage:        "plan",
		BodyMarkdown: "Build UI and mark the review milestone.",
	}); err != nil {
		t.Fatalf("CreateMessage() error = %v", err)
	}

	service := NewService(
		store,
		runtimeconfig.NewService(store, store, clock),
		&fakeWorkspaceRuntime{workspace: ws},
		&fakeRunner{result: RunResult{
			Status: workflow.RunStatusSucceeded,
			ResultJSON: `{
				"plan_summary_markdown":"One execution lane plus milestone.",
				"plan_mode":"initial",
				"execution_mode":"plan_only",
				"leader_reply":{"markdown":"先确认这个图。","type":"summary"},
				"tasks":[
					{"key":"ui","title":"Build UI","body_markdown":"Build the UI.","acceptance_markdown":"UI works.","kind":"execution","deliverables":["apps/web/src"],"priority":10,"task_order":1,"depends_on":[]},
					{"key":"ready-for-demo","title":"Ready for Demo","body_markdown":"Aggregate completion.","acceptance_markdown":"Milestone reached.","kind":"milestone","priority":5,"task_order":2,"depends_on":["ui"]}
				]
			}`,
		}},
		clock,
		"",
	)

	result, err := service.ProcessOnce(ctx)
	if err != nil {
		t.Fatalf("ProcessOnce() error = %v", err)
	}
	if result == nil {
		t.Fatal("expected leader result")
	}
	lanes, err := store.ListLanesByTopic(ctx, topicRecord.ID)
	if err != nil {
		t.Fatalf("ListLanesByTopic() error = %v", err)
	}
	if len(lanes) != 1 {
		t.Fatalf("expected milestone to reuse the execution lane, got %#v", lanes)
	}
	tasks, err := store.ListTasksByTopic(ctx, topicRecord.ID)
	if err != nil {
		t.Fatalf("ListTasksByTopic() error = %v", err)
	}
	if len(tasks) != 2 || tasks[0].LaneID != tasks[1].LaneID {
		t.Fatalf("expected milestone and execution task to share a lane, got %#v", tasks)
	}
}

func TestProcessOnceStartsOnlyGateLanesInitially(t *testing.T) {
	ctx := context.Background()
	clock := timeutil.FixedClock{Time: time.Date(2026, 3, 17, 5, 0, 0, 0, time.UTC)}
	store, err := sqlitestore.OpenInMemory(clock)
	if err != nil {
		t.Fatalf("OpenInMemory() error = %v", err)
	}
	defer store.Close()

	ws, topicRecord := seedLeaderLoopWorkspace(t, ctx, store, clock)
	if _, err := store.CreateMessage(ctx, message.Record{
		WorkspaceID:  ws.ID,
		TopicID:      topicRecord.ID,
		FromRoleName: "user",
		ToExpr:       "leader",
		Type:         message.TypeChat,
		Stage:        "plan",
		BodyMarkdown: "Build a gated todo app.",
	}); err != nil {
		t.Fatalf("CreateMessage() error = %v", err)
	}

	fakeRuntime := &fakeWorkspaceRuntime{workspace: ws}
	service := NewService(
		store,
		runtimeconfig.NewService(store, store, clock),
		fakeRuntime,
		&fakeRunner{result: RunResult{
			Status: workflow.RunStatusSucceeded,
			ResultJSON: `{
				"plan_summary_markdown":"Start with foundation gating.",
				"plan_mode":"initial",
				"execution_mode":"plan_only",
				"leader_reply":{"markdown":"先跑基础检查。","type":"decision"},
				"tasks":[
					{"key":"gate","title":"Check workspace baseline","body_markdown":"Validate setup.","acceptance_markdown":"Setup is valid.","kind":"gate","deliverables":["reports/gate.md"],"priority":10,"task_order":1,"depends_on":[]},
					{"key":"ui","title":"Build UI","body_markdown":"Implement the UI.","acceptance_markdown":"UI works.","kind":"execution","deliverables":["apps/web/src"],"priority":10,"task_order":1,"depends_on":[]}
				]
			}`,
		}},
		clock,
		"",
	)

	result, err := service.ProcessOnce(ctx)
	if err != nil {
		t.Fatalf("ProcessOnce() error = %v", err)
	}
	if result == nil {
		t.Fatal("expected result")
	}
	lanes, err := store.ListLanesByTopic(ctx, topicRecord.ID)
	if err != nil {
		t.Fatalf("ListLanesByTopic() error = %v", err)
	}
	tasks, err := store.ListTasksByTopic(ctx, topicRecord.ID)
	if err != nil {
		t.Fatalf("ListTasksByTopic() error = %v", err)
	}
	var gateTask, uiTask task.Record
	for _, item := range tasks {
		if item.Kind == task.KindGate {
			gateTask = item
		}
		if item.Title == "Build UI" {
			uiTask = item
		}
	}
	if len(lanes) != 1 {
		t.Fatalf("expected gate task to reuse the execution lane, got %#v", lanes)
	}
	if gateTask.LaneID == "" || gateTask.LaneID != uiTask.LaneID {
		t.Fatalf("expected gate and execution task to share one lane, got gate=%#v ui=%#v", gateTask, uiTask)
	}
	if gateTask.Status != task.StatusReady {
		t.Fatalf("expected gate task ready, got %#v", gateTask)
	}
	if uiTask.Status != task.StatusDraft {
		t.Fatalf("expected non-gate task blocked behind gate, got %#v", uiTask)
	}
	if len(fakeRuntime.startedLaneIDs) != 0 {
		t.Fatalf("expected initial gated plan to wait for confirmation, got %#v", fakeRuntime.startedLaneIDs)
	}
	updatedTopic, err := store.GetTopic(ctx, topicRecord.ID)
	if err != nil {
		t.Fatalf("GetTopic() error = %v", err)
	}
	if updatedTopic.Status != "awaiting_confirmation" {
		t.Fatalf("expected awaiting_confirmation topic, got %#v lanes=%#v", updatedTopic, lanes)
	}
}

func TestProcessOncePlanOnlyDoesNotAutoStartReadyLanesAfterGateSuccess(t *testing.T) {
	ctx := context.Background()
	clock := timeutil.FixedClock{Time: time.Date(2026, 3, 17, 5, 30, 0, 0, time.UTC)}
	store, err := sqlitestore.OpenInMemory(clock)
	if err != nil {
		t.Fatalf("OpenInMemory() error = %v", err)
	}
	defer store.Close()

	ws, topicRecord := seedLeaderLoopWorkspace(t, ctx, store, clock)
	topicRecord.Status = "execution"
	if _, err := store.UpdateTopic(ctx, topicRecord); err != nil {
		t.Fatalf("UpdateTopic() error = %v", err)
	}
	gateChain, err := store.CreateLane(ctx, lane.Record{
		WorkspaceID:       ws.ID,
		TopicID:           topicRecord.ID,
		Name:              "Foundation",
		Slug:              "foundation",
		Status:            lane.StatusSucceeded,
		BranchName:        "lane/todo/foundation",
		WorktreePath:      filepath.Join(t.TempDir(), "foundation"),
		ContainerName:     "lane-foundation-test",
		CreatedByRoleName: "leader",
	})
	if err != nil {
		t.Fatalf("CreateLane(gate) error = %v", err)
	}
	frontendChain, err := store.CreateLane(ctx, lane.Record{
		WorkspaceID:       ws.ID,
		TopicID:           topicRecord.ID,
		Name:              "Frontend",
		Slug:              "frontend",
		Status:            lane.StatusReady,
		BranchName:        "lane/todo/frontend",
		WorktreePath:      filepath.Join(t.TempDir(), "frontend"),
		ContainerName:     "lane-frontend-test",
		CreatedByRoleName: "leader",
	})
	if err != nil {
		t.Fatalf("CreateLane(frontend) error = %v", err)
	}
	if _, err := store.CreateTask(ctx, task.Record{
		WorkspaceID:       ws.ID,
		TopicID:           topicRecord.ID,
		LaneID:            gateChain.ID,
		Title:             "Check workspace baseline",
		BodyMarkdown:      "Validate setup.",
		Kind:              task.KindGate,
		Status:            task.StatusSucceeded,
		Priority:          10,
		TaskOrder:         1,
		CreatedByRoleName: "leader",
	}, nil); err != nil {
		t.Fatalf("CreateTask(gate) error = %v", err)
	}
	if _, err := store.CreateTask(ctx, task.Record{
		WorkspaceID:       ws.ID,
		TopicID:           topicRecord.ID,
		LaneID:            frontendChain.ID,
		Title:             "Build UI",
		BodyMarkdown:      "Implement UI.",
		Kind:              task.KindExecution,
		Status:            task.StatusReady,
		Priority:          10,
		TaskOrder:         1,
		CreatedByRoleName: "leader",
	}, nil); err != nil {
		t.Fatalf("CreateTask(frontend) error = %v", err)
	}
	if _, err := store.CreateMessage(ctx, message.Record{
		WorkspaceID:  ws.ID,
		TopicID:      topicRecord.ID,
		FromRoleName: "worker",
		ToExpr:       "leader",
		Type:         message.TypeSummary,
		Stage:        "execution",
		BodyMarkdown: "Foundation gate completed successfully. Keep the next lane stopped for now.",
	}); err != nil {
		t.Fatalf("CreateMessage() error = %v", err)
	}

	fakeRuntime := &fakeWorkspaceRuntime{workspace: ws}
	service := NewService(
		store,
		runtimeconfig.NewService(store, store, clock),
		fakeRuntime,
		&fakeRunner{result: RunResult{
			Status: workflow.RunStatusSucceeded,
			ResultJSON: `{
				"plan_summary_markdown":"Gate passed; continue existing plan.",
				"plan_mode":"patch",
				"replan_reason":"Gate completed successfully; continue existing graph.",
				"execution_mode":"plan_only",
				"leader_reply":{"markdown":"基础检查通过，继续后续链路。","type":"decision"},
				"tasks":[]
				}`,
		}},
		clock,
		"",
	)

	result, err := service.ProcessOnce(ctx)
	if err != nil {
		t.Fatalf("ProcessOnce() error = %v", err)
	}
	if result == nil {
		t.Fatal("expected result")
	}
	if len(fakeRuntime.startedLaneIDs) != 0 {
		t.Fatalf("expected plan_only to keep lanes stopped, got %#v", fakeRuntime.startedLaneIDs)
	}
}

func TestProcessOncePlanAndStartAutoStartsReadyLanesAfterGateSuccess(t *testing.T) {
	ctx := context.Background()
	clock := timeutil.FixedClock{Time: time.Date(2026, 3, 17, 5, 35, 0, 0, time.UTC)}
	store, err := sqlitestore.OpenInMemory(clock)
	if err != nil {
		t.Fatalf("OpenInMemory() error = %v", err)
	}
	defer store.Close()

	ws, topicRecord := seedLeaderLoopWorkspace(t, ctx, store, clock)
	topicRecord.Status = "execution"
	if _, err := store.UpdateTopic(ctx, topicRecord); err != nil {
		t.Fatalf("UpdateTopic() error = %v", err)
	}
	gateChain, err := store.CreateLane(ctx, lane.Record{
		WorkspaceID:       ws.ID,
		TopicID:           topicRecord.ID,
		Name:              "Foundation",
		Slug:              "foundation",
		Status:            lane.StatusSucceeded,
		BranchName:        "lane/todo/foundation",
		WorktreePath:      filepath.Join(t.TempDir(), "foundation"),
		ContainerName:     "lane-foundation-test",
		CreatedByRoleName: "leader",
	})
	if err != nil {
		t.Fatalf("CreateLane(gate) error = %v", err)
	}
	frontendChain, err := store.CreateLane(ctx, lane.Record{
		WorkspaceID:       ws.ID,
		TopicID:           topicRecord.ID,
		Name:              "Frontend",
		Slug:              "frontend",
		Status:            lane.StatusReady,
		BranchName:        "lane/todo/frontend",
		WorktreePath:      filepath.Join(t.TempDir(), "frontend"),
		ContainerName:     "lane-frontend-test",
		CreatedByRoleName: "leader",
	})
	if err != nil {
		t.Fatalf("CreateLane(frontend) error = %v", err)
	}
	if _, err := store.CreateTask(ctx, task.Record{
		WorkspaceID:       ws.ID,
		TopicID:           topicRecord.ID,
		LaneID:            gateChain.ID,
		Title:             "Check workspace baseline",
		BodyMarkdown:      "Validate setup.",
		Kind:              task.KindGate,
		Status:            task.StatusSucceeded,
		Priority:          10,
		TaskOrder:         1,
		CreatedByRoleName: "leader",
	}, nil); err != nil {
		t.Fatalf("CreateTask(gate) error = %v", err)
	}
	if _, err := store.CreateTask(ctx, task.Record{
		WorkspaceID:       ws.ID,
		TopicID:           topicRecord.ID,
		LaneID:            frontendChain.ID,
		Title:             "Build UI",
		BodyMarkdown:      "Implement UI.",
		Kind:              task.KindExecution,
		Status:            task.StatusReady,
		Priority:          10,
		TaskOrder:         1,
		CreatedByRoleName: "leader",
	}, nil); err != nil {
		t.Fatalf("CreateTask(frontend) error = %v", err)
	}
	if _, err := store.CreateMessage(ctx, message.Record{
		WorkspaceID:  ws.ID,
		TopicID:      topicRecord.ID,
		FromRoleName: "worker",
		ToExpr:       "leader",
		Type:         message.TypeSummary,
		Stage:        "execution",
		BodyMarkdown: "Foundation gate completed successfully. Start the next ready lane.",
	}); err != nil {
		t.Fatalf("CreateMessage() error = %v", err)
	}

	fakeRuntime := &fakeWorkspaceRuntime{workspace: ws}
	service := NewService(
		store,
		runtimeconfig.NewService(store, store, clock),
		fakeRuntime,
		&fakeRunner{result: RunResult{
			Status: workflow.RunStatusSucceeded,
			ResultJSON: `{
				"plan_summary_markdown":"Gate passed; continue existing plan.",
				"plan_mode":"patch",
				"replan_reason":"Gate completed successfully; continue existing graph.",
				"execution_mode":"plan_and_start",
				"leader_reply":{"markdown":"基础检查通过，继续后续链路。","type":"decision"},
				"tasks":[]
				}`,
		}},
		clock,
		"",
	)

	result, err := service.ProcessOnce(ctx)
	if err != nil {
		t.Fatalf("ProcessOnce() error = %v", err)
	}
	if result == nil {
		t.Fatal("expected result")
	}
	if len(fakeRuntime.startedLaneIDs) != 1 || fakeRuntime.startedLaneIDs[0] != frontendChain.ID {
		t.Fatalf("expected auto-start of frontend lane, got %#v", fakeRuntime.startedLaneIDs)
	}
}

func TestProcessOnceUsesResolvedLeaderPromptOverrides(t *testing.T) {
	ctx := context.Background()
	clock := timeutil.FixedClock{Time: time.Date(2026, 3, 17, 6, 0, 0, 0, time.UTC)}
	store, err := sqlitestore.OpenInMemory(clock)
	if err != nil {
		t.Fatalf("OpenInMemory() error = %v", err)
	}
	defer store.Close()

	ws, topicRecord := seedLeaderLoopWorkspace(t, ctx, store, clock)
	if _, err := store.UpsertRolePrompt(ctx, role.Prompt{
		RoleName:        "leader",
		WorkspaceID:     ws.ID,
		PromptKind:      role.PromptSystem,
		ContentMarkdown: "你是自定义 leader。\n\n优先把范围压缩到最小可执行图。",
	}, "test"); err != nil {
		t.Fatalf("UpsertRolePrompt() error = %v", err)
	}
	if _, err := store.CreateMessage(ctx, message.Record{
		WorkspaceID:  ws.ID,
		TopicID:      topicRecord.ID,
		FromRoleName: "user",
		ToExpr:       "leader",
		Type:         message.TypeChat,
		Stage:        "plan",
		BodyMarkdown: "Build a todo app.",
	}); err != nil {
		t.Fatalf("CreateMessage() error = %v", err)
	}

	runner := &fakeRunner{result: RunResult{
		Status: workflow.RunStatusSucceeded,
		ResultJSON: `{
			"plan_summary_markdown":"Need clarification first.",
			"plan_mode":"initial",
			"execution_mode":"clarify",
			"leader_reply":{"markdown":"先缩小范围。","type":"question"},
			"tasks":[]
		}`,
	}}
	service := NewService(
		store,
		runtimeconfig.NewService(store, store, clock),
		&fakeWorkspaceRuntime{workspace: ws},
		runner,
		clock,
		"",
	)

	if _, err := service.ProcessOnce(ctx); err != nil {
		t.Fatalf("ProcessOnce() error = %v", err)
	}
	if !strings.Contains(runner.prompt, "你是自定义 leader。") {
		t.Fatalf("expected custom leader prompt in runtime instructions, got %q", runner.prompt)
	}
	if strings.Contains(runner.prompt, defaultLeaderSystemPrompt) {
		t.Fatalf("expected custom prompt to replace fallback system prompt, got %q", runner.prompt)
	}
}

func TestValidateLeaderOutputForTopicRejectsPatchOnEmptyGraph(t *testing.T) {
	err := validateLeaderOutputForTopic(leaderOutput{
		PlanSummaryMarkdown: "Patch on empty graph.",
		PlanMode:            "patch",
		ReplanReason:        "Need to update graph.",
		ExecutionMode:       "plan_only",
		LeaderReply:         leaderReplySpec{Markdown: "Patch.", Type: "summary"},
	}, nil, nil)
	if err == nil || !strings.Contains(err.Error(), "cannot use plan_mode=patch on an empty topic graph") {
		t.Fatalf("expected patch on empty graph error, got %v", err)
	}
}

func TestValidateLeaderOutputForTopicRejectsInitialOnExistingGraph(t *testing.T) {
	err := validateLeaderOutputForTopic(leaderOutput{
		PlanSummaryMarkdown: "Initial on existing graph.",
		PlanMode:            "initial",
		ReplanReason:        "",
		ExecutionMode:       "plan_only",
		LeaderReply:         leaderReplySpec{Markdown: "Initial.", Type: "summary"},
	}, []lane.Record{{ID: "chain_1", Slug: "ui-chain", Name: "UI Chain"}}, nil)
	if err == nil || !strings.Contains(err.Error(), "must use plan_mode=patch") {
		t.Fatalf("expected initial on existing graph error, got %v", err)
	}
}

func TestValidateLeaderOutputForTopicRejectsPatchWithoutReason(t *testing.T) {
	err := validateLeaderOutputForTopic(leaderOutput{
		PlanSummaryMarkdown: "Patch without reason.",
		PlanMode:            "patch",
		ReplanReason:        "",
		ExecutionMode:       "plan_only",
		LeaderReply:         leaderReplySpec{Markdown: "Patch.", Type: "summary"},
	}, []lane.Record{{ID: "chain_1", Slug: "ui-chain", Name: "UI Chain"}}, nil)
	if err == nil || !strings.Contains(err.Error(), "requires replan_reason") {
		t.Fatalf("expected patch without reason error, got %v", err)
	}
}

func TestValidateLeaderOutputForTopicAllowsPatchDependenciesOnExistingTaskIDs(t *testing.T) {
	err := validateLeaderOutputForTopic(leaderOutput{
		PlanSummaryMarkdown: "Patch existing graph.",
		PlanMode:            "patch",
		ReplanReason:        "Attach a follow-up task to the completed gate.",
		ExecutionMode:       "plan_only",
		LeaderReply:         leaderReplySpec{Markdown: "Continue from the existing gate.", Type: "summary"},
		Tasks: []leaderTaskSpec{
			{
				Key:                "follow-up",
				Title:              "Continue implementation",
				BodyMarkdown:       "Build the next step.",
				AcceptanceMarkdown: "Ready to proceed.",
				Kind:               "execution",
				Deliverables:       []string{"apps/web/src"},
				Priority:           10,
				TaskOrder:          2,
				DependsOn:          []string{"task-existing"},
			},
		},
	}, []lane.Record{{ID: "chain_1", Slug: "ui-chain", Name: "UI Chain"}}, []task.Record{{ID: "task-existing", Title: "Existing Gate"}})
	if err != nil {
		t.Fatalf("expected existing task dependency to validate, got %v", err)
	}
}

func TestValidateLeaderOutputForTopicRejectsUnknownPatchDependencyKey(t *testing.T) {
	err := validateLeaderOutputForTopic(leaderOutput{
		PlanSummaryMarkdown: "Patch existing graph.",
		PlanMode:            "patch",
		ReplanReason:        "Attach a follow-up task to the completed gate.",
		ExecutionMode:       "plan_only",
		LeaderReply:         leaderReplySpec{Markdown: "Continue from the existing gate.", Type: "summary"},
		Tasks: []leaderTaskSpec{
			{
				Key:                "follow-up",
				Title:              "Continue implementation",
				BodyMarkdown:       "Build the next step.",
				AcceptanceMarkdown: "Ready to proceed.",
				Kind:               "execution",
				Deliverables:       []string{"apps/web/src"},
				Priority:           10,
				TaskOrder:          2,
				DependsOn:          []string{"missing-task"},
			},
		},
	}, []lane.Record{{ID: "chain_1", Slug: "ui-chain", Name: "UI Chain"}}, []task.Record{{ID: "task-existing", Title: "Existing Gate"}})
	if err == nil || !strings.Contains(err.Error(), "unknown dependency key") {
		t.Fatalf("expected unknown dependency key error, got %v", err)
	}
}

func TestLeaderCommandEnvWritesRuntimeCodexHomeUnderProjectRuntime(t *testing.T) {
	projectRoot := t.TempDir()
	env := leaderCommandEnv(projectRoot, runtimeconfig.ResolvedRole{
		WorkspaceID: "ws_1",
		Role:        role.Definition{Name: "leader"},
		Config: role.Config{
			RoleName: "leader",
			ConfigTOML: strings.Join([]string{
				`model = "gpt-5.4"`,
				`model_provider = "custom"`,
				``,
				`[model_providers.custom]`,
				`base_url = "http://example.test/v1"`,
				`wire_api = "responses"`,
			}, "\n"),
			AuthJSON: `{"OPENAI_API_KEY":"token-1"}`,
		},
	})

	expectedHome := runtimecodex.HostLeaderHomeDir(projectRoot, "ws_1", "leader")
	expectedCodexHome := runtimecodex.HostLeaderCodexDir(projectRoot, "ws_1", "leader")
	joined := strings.Join(env, "\n")
	if !strings.Contains(joined, "HOME="+expectedHome) {
		t.Fatalf("expected isolated HOME in env, env=%q", joined)
	}
	if !strings.Contains(joined, "CODEX_HOME="+expectedCodexHome) {
		t.Fatalf("expected isolated CODEX_HOME in env, env=%q", joined)
	}

	configBytes, err := os.ReadFile(filepath.Join(expectedCodexHome, "config.toml"))
	if err != nil {
		t.Fatalf("ReadFile(config.toml) error = %v", err)
	}
	configText := string(configBytes)
	for _, needle := range []string{
		`model = "gpt-5.4"`,
		`model_provider = "custom"`,
		`[model_providers.custom]`,
		`base_url = "http://example.test/v1"`,
	} {
		if !strings.Contains(configText, needle) {
			t.Fatalf("expected seeded config to contain %q, got:\n%s", needle, configText)
		}
	}
	authBytes, err := os.ReadFile(filepath.Join(expectedCodexHome, "auth.json"))
	if err != nil {
		t.Fatalf("ReadFile(auth.json) error = %v", err)
	}
	var auth map[string]any
	if err := json.Unmarshal(authBytes, &auth); err != nil {
		t.Fatalf("Unmarshal(auth.json) error = %v", err)
	}
	if auth["OPENAI_API_KEY"] != "token-1" {
		t.Fatalf("unexpected copied auth.json: %s", string(authBytes))
	}
}

func assertSchemaRequiredMatchesProperties(t *testing.T, schema map[string]any) {
	t.Helper()

	properties, ok := schema["properties"].(map[string]any)
	if !ok {
		t.Fatalf("schema properties missing or invalid: %#v", schema)
	}
	requiredRaw, ok := schema["required"].([]any)
	if !ok {
		t.Fatalf("schema required missing or invalid: %#v", schema)
	}

	required := make(map[string]struct{}, len(requiredRaw))
	for _, item := range requiredRaw {
		key, ok := item.(string)
		if !ok {
			t.Fatalf("schema required item must be string, got %#v", item)
		}
		required[key] = struct{}{}
	}

	for key := range properties {
		if _, ok := required[key]; !ok {
			t.Fatalf("schema required is missing property %q", key)
		}
	}
}

type fakeRunner struct {
	result RunResult
	prompt string
}

func (f *fakeRunner) Run(_ context.Context, _ string, _ runtimeconfig.ResolvedRole, prompt, _ string) (RunResult, error) {
	f.prompt = prompt
	return f.result, nil
}

type fakeWorkspaceRuntime struct {
	workspace      workspace.Workspace
	startedLaneID  string
	startedLaneIDs []string
}

func (f *fakeWorkspaceRuntime) Ensure(_ context.Context, _ string) (workspace.Workspace, workspaceruntime.Runtime, error) {
	return f.workspace, workspaceruntime.Runtime{}, nil
}

func (f *fakeWorkspaceRuntime) EnsureLane(_ context.Context, laneID string) (lane.Record, error) {
	f.startedLaneID = laneID
	f.startedLaneIDs = append(f.startedLaneIDs, laneID)
	return lane.Record{ID: laneID, Name: "UI Chain", Status: lane.StatusRunning}, nil
}

func seedLeaderLoopWorkspace(t *testing.T, ctx context.Context, store *sqlitestore.Store, clock timeutil.Clock) (workspace.Workspace, topic.Record) {
	t.Helper()
	now := timeutil.FormatRFC3339(clock.Now())
	project, err := store.CreateProject(ctx, workspace.Project{
		Slug:          "demo",
		Name:          "Demo",
		RootPath:      t.TempDir(),
		DefaultBranch: "main",
		Status:        "active",
		CreatedAt:     now,
		UpdatedAt:     now,
	})
	if err != nil {
		t.Fatalf("CreateProject() error = %v", err)
	}
	ws, err := store.CreateWorkspace(ctx, workspace.Workspace{
		ProjectID:      project.ID,
		Slug:           "todo",
		Name:           "todo",
		RootPath:       t.TempDir(),
		BaseBranch:     "main",
		WorktreeBranch: "worktree/todo",
		RuntimeBackend: "host",
		Status:         "active",
		CreatedAt:      now,
		UpdatedAt:      now,
	})
	if err != nil {
		t.Fatalf("CreateWorkspace() error = %v", err)
	}
	record, err := store.CreateTopic(ctx, topic.Record{
		WorkspaceID: ws.ID,
		Slug:        "v1",
		Title:       "v1",
		Space:       topic.SpaceWorkflow,
		Status:      "plan",
		CreatedAt:   now,
		UpdatedAt:   now,
	})
	if err != nil {
		t.Fatalf("CreateTopic() error = %v", err)
	}
	return ws, record
}