Skip to content

Self-hosted workflows for coding-agent delivery. Orchestrate CodeBuddy, Codex and Claude Code with scripts and human approval gates. Includes Local workflows for coding assistants.

30.1 KB
Raw Blame
package httpapi

import (
	"agentflow/internal/engine"
	"agentflow/internal/runtime"
	"agentflow/internal/tracker"
	"bytes"
	"context"
	"encoding/json"
	"fmt"
	"os"
	"path/filepath"
	"strings"
	"testing"

	"agentflow/internal/domain"
	"agentflow/internal/repo"
)

func TestPersonalConversationRunsInItsOwnRootWithProjectSkills(t *testing.T) {
	h, u := workbenchFixture(t)
	if err := h.repo.PutProject(domain.Project{ID: "other", Name: "Other", OwnerID: u.ID}); err != nil {
		t.Fatal(err)
	}
	for _, skill := range []domain.SkillDefinition{
		{ID: "notes", Name: "notes", ProjectID: "workbench", Content: "记录要点"},
		{ID: "shared-notes", Name: "shared-notes", ProjectID: "other", Shared: true, Content: "共享要点"},
	} {
		if err := h.repo.PutSkill(skill); err != nil {
			t.Fatal(err)
		}
	}
	root := t.TempDir()
	bin := filepath.Join(root, "codebuddy")
	homeFile := filepath.Join(root, "home")
	script := `#!/bin/sh
printf '%s' "$HOME" > '` + homeFile + `'
printf '%s\n' '{"type":"result","result":"好"}'
`
	if err := os.WriteFile(bin, []byte(script), 0700); err != nil {
		t.Fatal(err)
	}
	t.Setenv("AGENTFLOW_CODEBUDDY_BIN", bin)
	send := func(project, session string) string {
		body, _ := json.Marshal(assistantRequest{ProjectID: project, SessionID: session, Messages: []assistantMessage{{Role: "user", Content: "你好"}}})
		c, w := workbenchContext(u, "POST", "/api/assistant/chat", bytes.NewBuffer(body))
		h.chat(c)
		if w.Code != 200 {
			t.Fatal(w.Code, w.Body.String())
		}
		home, _ := os.ReadFile(homeFile)
		return string(home)
	}
	home := send("workbench", "personal-a")
	if home != filepath.Join(assistantConversationRoot(u.ID, "personal-a"), "home") {
		t.Fatalf("home=%s", home)
	}
	if _, err := os.Stat(filepath.Join(home, ".codebuddy", "skills", "notes", "SKILL.md")); err != nil {
		t.Fatal("project skill not written to the conversation home", err)
	}
	other := send("", "personal-b")
	if other == home || strings.HasPrefix(other, assistantCLIHome(u.ID)) {
		t.Fatalf("conversations share a CLI home: %s", other)
	}
	if _, err := os.Stat(filepath.Join(other, ".codebuddy", "skills", "notes", "SKILL.md")); !os.IsNotExist(err) {
		t.Fatal("a conversation without a project received a project skill", err)
	}
	if _, err := os.Stat(filepath.Join(other, ".codebuddy", "skills", "shared-notes", "SKILL.md")); err != nil {
		t.Fatal("a conversation without a project did not receive the shared skill", err)
	}
	if assistantConversationRoot(u.ID, "same") == assistantConversationRoot(u.ID+1, "same") {
		t.Fatal("a reused session ID reaches another user's root")
	}
}

func TestConversationRootsFollowConversationDir(t *testing.T) {
	sessions, conversations := t.TempDir(), t.TempDir()
	t.Setenv("AGENTFLOW_ASSISTANT_SESSION_DIR", sessions)
	under := func(root, base, kind string) bool {
		return filepath.Base(filepath.Dir(root)) == kind && filepath.Dir(filepath.Dir(root)) == base
	}
	for _, unset := range []string{"", "  "} {
		t.Setenv("AGENTFLOW_CONVERSATION_DIR", unset)
		if root := assistantConversationRoot(7, "s"); !under(root, sessions, "conversations") {
			t.Fatalf("personal root with AGENTFLOW_CONVERSATION_DIR=%q = %s", unset, root)
		}
		if root := assistantSharedSessionRoot("s"); !under(root, sessions, "shared") {
			t.Fatalf("shared root with AGENTFLOW_CONVERSATION_DIR=%q = %s", unset, root)
		}
	}
	t.Setenv("AGENTFLOW_CONVERSATION_DIR", conversations)
	if root := assistantConversationRoot(7, "s"); !under(root, conversations, "conversations") {
		t.Fatalf("personal root = %s, want under %s", root, conversations)
	}
	if root := assistantSharedSessionRoot("s"); !under(root, conversations, "shared") {
		t.Fatalf("shared root = %s, want under %s", root, conversations)
	}
	for _, path := range []string{assistantSessionRoot(7), assistantCLIHome(7), workbenchAttachmentDir(7)} {
		if !strings.HasPrefix(path, sessions+string(filepath.Separator)) {
			t.Fatalf("per-user state %s left AGENTFLOW_ASSISTANT_SESSION_DIR", path)
		}
	}

	native := filepath.Join(assistantConversationRoot(7, "s"), "home", "state")
	attachment := filepath.Join(workbenchAttachmentDir(7), "kept.bin")
	for _, file := range []string{native, attachment} {
		if err := os.MkdirAll(filepath.Dir(file), 0700); err != nil {
			t.Fatal(err)
		}
		if err := os.WriteFile(file, []byte("x"), 0600); err != nil {
			t.Fatal(err)
		}
	}
	deleteAssistantCLISession(7, "s")
	if _, err := os.Stat(assistantConversationRoot(7, "s")); !os.IsNotExist(err) {
		t.Fatalf("deleting the conversation left its root: %v", err)
	}
	if _, err := os.Stat(attachment); err != nil {
		t.Fatalf("deleting the conversation removed per-user state: %v", err)
	}
}

func TestProjectConversationIsolatesReferencesAndOffersProjectRoles(t *testing.T) {
	h, u := workbenchFixture(t)
	h.repo.PutProject(domain.Project{ID: "other", Name: "Other", OwnerID: u.ID})
	for _, role := range []domain.AgentDefinition{
		{ID: "dev", Name: "开发", ProjectID: "workbench", Prompt: "实现"},
		{ID: "ops", Name: "运维", ProjectID: "other", Prompt: "部署"},
		{ID: "reviewer", Name: "评审", ProjectID: "other", Shared: true, Prompt: "评审"},
	} {
		h.repo.PutAgent(role)
	}
	h.repo.PutIssue(domain.Issue{ID: "other-issue", Title: "别的需求", ProjectID: "other"})
	c, _ := workbenchContext(u, "POST", "/", bytes.NewBuffer(nil))
	prepare := func(project string, refs ...domain.AssistantReference) (assistantRequest, error) {
		req := assistantRequest{ProjectID: project, Messages: []assistantMessage{{Role: "user", Content: "看看", References: refs}}}
		return req, h.prepareWorkbenchContext(c, &req, u)
	}
	req, err := prepare("workbench")
	if err != nil || len(req.roles) != 1 || req.roles[0].Role.ID != "dev" || !strings.Contains(req.contextText, "subagent_type=role-<角色ID>") {
		t.Fatalf("project roles not offered unmentioned: %+v %v", req.roles, err)
	}
	for _, ref := range []domain.AssistantReference{{Type: "agent", ID: "ops"}, {Type: "issue", ID: "other-issue"}} {
		if _, err := prepare("workbench", ref); err != errForeignReference {
			t.Fatalf("%s from another project accepted: %v", ref.ID, err)
		}
	}
	req, err = prepare("workbench", domain.AssistantReference{Type: "agent", ID: "reviewer"})
	if err != nil || len(req.roles) != 2 {
		t.Fatalf("shared role rejected or not offered: %+v %v", req.roles, err)
	}
	if _, err := prepare("", domain.AssistantReference{Type: "issue", ID: "other-issue"}); err != nil {
		t.Fatal("a personal conversation lost cross-project references", err)
	}
}

func TestSkillMentionsAreScopedHintedAndWrittenToHome(t *testing.T) {
	h, u := workbenchFixture(t)
	h.repo.PutProject(domain.Project{ID: "other", Name: "Other", OwnerID: u.ID})
	for _, skill := range []domain.SkillDefinition{
		{ID: "lint", Name: "代码检查", ProjectID: "workbench", Content: "检查"},
		{ID: "Shared_Doc", Name: "写文档", ProjectID: "other", Shared: true, Content: "文档"},
		{ID: "deploy", Name: "部署", ProjectID: "other", Content: "部署"},
	} {
		if err := h.repo.PutSkill(skill); err != nil {
			t.Fatal(err)
		}
	}
	c, rec := workbenchContext(u, "GET", "/api/assistant/references?projectId=workbench&type=skill", bytes.NewBuffer(nil))
	h.workbenchReferences(c)
	var found []domain.AssistantReference
	json.Unmarshal(rec.Body.Bytes(), &found)
	ids := map[string]bool{}
	for _, item := range found {
		ids[item.ID] = true
	}
	if !ids["lint"] || !ids["Shared_Doc"] || ids["deploy"] {
		t.Fatalf("project skill search=%s", rec.Body.String())
	}
	c, _ = workbenchContext(u, "POST", "/", bytes.NewBuffer(nil))
	req := assistantRequest{ProjectID: "workbench", Messages: []assistantMessage{{Role: "user", Content: "写一下", References: []domain.AssistantReference{{Type: "skill", ID: "Shared_Doc"}}}}}
	if err := h.prepareWorkbenchContext(c, &req, u); err != nil {
		t.Fatal(err)
	}
	if !strings.Contains(req.contextText, "skill=shareddoc") || req.Messages[0].References[0].Name != "写文档" {
		t.Fatalf("skill hint missing: %s", req.contextText)
	}
	root := t.TempDir()
	// Sharing installs the skill on a project turn that never mentions it.
	plain := assistantRequest{ProjectID: "workbench", Messages: []assistantMessage{{Role: "user", Content: "写一下"}}}
	if err := h.writeConversationAssets(root, plain); err != nil {
		t.Fatal(err)
	}
	for _, name := range []string{"lint", "shareddoc"} {
		if _, err := os.Stat(filepath.Join(root, "home", ".codebuddy", "skills", name, "SKILL.md")); err != nil {
			t.Fatalf("skill %s not written: %v", name, err)
		}
	}
	if _, err := os.Stat(filepath.Join(root, "home", ".codebuddy", "skills", "deploy", "SKILL.md")); !os.IsNotExist(err) {
		t.Fatalf("another project's private skill was installed: %v", err)
	}
	req.Messages[0].References = []domain.AssistantReference{{Type: "skill", ID: "deploy"}}
	if err := h.prepareWorkbenchContext(c, &req, u); err != errForeignReference {
		t.Fatalf("another project's skill accepted: %v", err)
	}
	run := domain.Run{WorkflowSnapshot: domain.WorkflowDefinition{Nodes: []domain.WorkflowNode{{ID: "n", AgentID: "dev"}}}}
	h.repo.PutAgent(domain.AgentDefinition{ID: "dev", Name: "开发", ProjectID: "workbench", Skills: []string{"lint"}})
	if !h.taskReferenceAllowed(run, "skill", "lint") || h.taskReferenceAllowed(run, "skill", "Shared_Doc") {
		t.Fatal("task skill references must follow the task's roles")
	}
}

// Every shared skill on the platform reaches the CLI home, whichever project
// owns it, while private skills of other projects stay out; a conversation
// without a project gets the same shared set. A shared skill nobody mentioned
// brings only its SKILL.md; mentioning it installs its other files too.
func TestEverySharedSkillIsInstalledWithItsSkillMD(t *testing.T) {
	h, u := workbenchFixture(t)
	for _, project := range []string{"docs", "ops"} {
		if err := h.repo.PutProject(domain.Project{ID: project, Name: project, OwnerID: u.ID}); err != nil {
			t.Fatal(err)
		}
	}
	runbook := domain.SkillDefinition{ID: "ops-runbook", Name: "ops-runbook", ProjectID: "ops", Shared: true, Content: "runbook", Files: map[string]string{"scripts/check.sh": "echo ok"}}
	for _, skill := range []domain.SkillDefinition{
		{ID: "own", Name: "own", ProjectID: "workbench", Content: "own"},
		{ID: "docs-writer", Name: "docs-writer", ProjectID: "docs", Shared: true, Content: "write"},
		{ID: "docs-draft", Name: "docs-draft", ProjectID: "docs", Content: "draft"},
		runbook,
		{ID: "ops-secret", Name: "ops-secret", ProjectID: "ops", Content: "secret"},
	} {
		if err := h.repo.PutSkill(skill); err != nil {
			t.Fatal(err)
		}
	}
	asset := []byte{0, 1, 2, 255}
	skillMD := []byte("---\nname: ops-runbook\ndescription: run the ops checks\n---\nRun scripts/check.sh.\n")
	if err := h.repo.PutSkillFiles("ops-runbook", []repo.SkillFileInput{
		{Path: "SKILL.md", Content: skillMD, Mode: 0o644},
		{Path: "assets/check.bin", Content: asset, Mode: 0o644},
	}); err != nil {
		t.Fatal(err)
	}
	stored, ok := h.repo.Skill("ops-runbook")
	if !ok {
		t.Fatal("ops-runbook not stored")
	}
	// The test store also seeds the platform's shared skills; they must be
	// installed too, so only the skills created here are pinned.
	for project, want := range map[string]map[string]bool{
		"workbench": {"own": true, "docs-writer": true, "ops-runbook": true, "repository-navigation": true, "docs-draft": false, "ops-secret": false},
		"":          {"own": false, "docs-writer": true, "ops-runbook": true, "repository-navigation": true, "docs-draft": false, "ops-secret": false},
	} {
		for _, mentioned := range []bool{false, true} {
			req := assistantRequest{ProjectID: project}
			if mentioned {
				req.skills = []domain.SkillDefinition{stored}
			}
			root := t.TempDir()
			if err := h.writeConversationAssets(root, req); err != nil {
				t.Fatal(err)
			}
			dir := filepath.Join(root, "home", ".codebuddy", "skills")
			entries, err := os.ReadDir(dir)
			if err != nil {
				t.Fatal(err)
			}
			got := map[string]bool{}
			for _, entry := range entries {
				got[entry.Name()] = true
			}
			for name, installed := range want {
				if got[name] != installed {
					t.Fatalf("project %q skill %s installed=%v, want %v (all: %v)", project, name, got[name], installed, got)
				}
			}
			if data, err := os.ReadFile(filepath.Join(dir, "ops-runbook", "SKILL.md")); err != nil || !bytes.Contains(data, []byte("Run scripts/check.sh.")) {
				t.Fatalf("project %q mentioned=%v shared SKILL.md = %q %v", project, mentioned, data, err)
			}
			for path, content := range map[string][]byte{"assets/check.bin": asset, "scripts/check.sh": []byte("echo ok")} {
				data, err := os.ReadFile(filepath.Join(dir, "ops-runbook", filepath.FromSlash(path)))
				if mentioned && (err != nil || !bytes.Equal(data, content)) {
					t.Fatalf("project %q mentioned shared skill file %s = %v %v", project, path, data, err)
				}
				if !mentioned && !os.IsNotExist(err) {
					t.Fatalf("project %q unmentioned shared skill file %s was installed: %v", project, path, err)
				}
			}
		}
	}
}

func TestEverySharedSkillIsInstalledHoweverManyAreShared(t *testing.T) {
	h, u := workbenchFixture(t)
	if err := h.repo.PutProject(domain.Project{ID: "docs", Name: "docs", OwnerID: u.ID}); err != nil {
		t.Fatal(err)
	}
	if err := h.repo.PutSkill(domain.SkillDefinition{ID: "own", Name: "own", ProjectID: "workbench", Content: "own"}); err != nil {
		t.Fatal(err)
	}
	if err := h.repo.PutSkill(domain.SkillDefinition{ID: "docs-private", Name: "docs-private", ProjectID: "docs", Content: "private"}); err != nil {
		t.Fatal(err)
	}
	// More shared skills than the 50 an earlier revision installed, so a
	// skill late in id order (the one a scheduled task needs) is still there.
	for i := 0; i < 120; i++ {
		id := fmt.Sprintf("zz-shared-%03d", i)
		if err := h.repo.PutSkill(domain.SkillDefinition{ID: id, Name: id, ProjectID: "docs", Shared: true, Content: id}); err != nil {
			t.Fatal(err)
		}
	}
	var shared []string
	for _, skill := range h.repo.Skills() {
		if skill.Shared && skill.ProjectID != "workbench" {
			shared = append(shared, skill.ID)
		}
	}
	if len(shared) < 120 {
		t.Fatalf("fixture has %d shared skills, want at least 120", len(shared))
	}
	for _, project := range []string{"workbench", ""} {
		root := t.TempDir()
		if err := h.writeConversationAssets(root, assistantRequest{ProjectID: project}); err != nil {
			t.Fatal(err)
		}
		entries, err := os.ReadDir(filepath.Join(root, "home", ".codebuddy", "skills"))
		if err != nil {
			t.Fatal(err)
		}
		got := map[string]bool{}
		for _, entry := range entries {
			got[entry.Name()] = true
		}
		if got["own"] != (project == "workbench") {
			t.Fatalf("project %q own skill installed=%v", project, got["own"])
		}
		if got["docs-private"] {
			t.Fatalf("project %q installed another project's private skill", project)
		}
		for _, id := range shared {
			if !got[id] {
				t.Fatalf("project %q shared skill %s not installed (installed %d of %d)", project, id, len(got), len(shared))
			}
		}
	}
}

func TestSubagentStreamEventsCarryTheirDispatch(t *testing.T) {
	dispatch := assistantStreamEvents(`{"type":"assistant","message":{"content":[{"type":"tool_use","id":"call-1","name":"Agent","input":{"subagent_type":"role-qa","description":"补单测","prompt":"x"}}]}}`)
	if len(dispatch) != 1 || dispatch[0].Subagent != "role-qa" || dispatch[0].Parent != "" || dispatch[0].Input != "x" || dispatch[0].Model != "" {
		t.Fatalf("dispatch=%+v", dispatch)
	}
	// A dispatch that names a model keeps it; one that only inherits does not.
	for input, want := range map[string]string{
		`"model":"claude-sonnet-4-5"`: "claude-sonnet-4-5",
		`"model":" lite "`:            "lite",
		`"model":"default"`:           "",
		`"model":"inherit"`:           "",
		`"model":"<synthetic>"`:       "",
	} {
		got := assistantStreamEvents(`{"type":"assistant","message":{"content":[{"type":"tool_use","id":"call-m","name":"Agent","input":{"subagent_type":"Explore","prompt":"x",` + input + `}}]}}`)
		if len(got) != 1 || got[0].Model != want {
			t.Fatalf("%s: dispatch=%+v, want model %q", input, got, want)
		}
	}
	// A subagent's line reports the model it actually runs on, under its
	// dispatch; Main Bot's own lines do not.
	ran := assistantStreamEvents(`{"type":"assistant","parent_tool_use_id":"call-1","message":{"model":"deepseek-v4.1-flash-ioa","content":[{"type":"text","text":"ok"}]}}`)
	if len(ran) != 2 || ran[0].Kind != "agentModel" || ran[0].Model != "deepseek-v4.1-flash-ioa" || ran[0].Parent != "call-1" {
		t.Fatalf("subagent line=%+v", ran)
	}
	// A synthesized line names no real model.
	if synthetic := assistantStreamEvents(`{"type":"assistant","parent_tool_use_id":"call-1","message":{"model":"<synthetic>","content":[{"type":"text","text":"ok"}]}}`); len(synthetic) != 1 || synthetic[0].Kind != "agentText" {
		t.Fatalf("synthetic line=%+v", synthetic)
	}
	if main := assistantStreamEvents(`{"type":"assistant","message":{"model":"deepseek-v4.1-flash-ioa","content":[{"type":"text","text":"ok"}]}}`); len(main) != 1 || main[0].Kind != "answer" {
		t.Fatalf("main line=%+v", main)
	}
	if got := labelRoleSubagent(dispatch[0], []roleSubagent{{Role: domain.AgentDefinition{ID: "qa", Name: "测试工程师"}}}); got.Role != "测试工程师" {
		t.Fatalf("role label=%q", got.Role)
	}
	inner := assistantStreamEvents(`{"type":"assistant","parent_tool_use_id":"call-1","message":{"content":[{"type":"thinking","thinking":"先看"},{"type":"text","text":"已补 3 个用例"}]}}`)
	if len(inner) != 2 || inner[0].Parent != "call-1" || inner[1].Kind != "agentText" || inner[1].Parent != "call-1" {
		t.Fatalf("subagent events=%+v", inner)
	}
	done := assistantStreamEvents(`{"type":"user","message":{"content":[{"type":"tool_result","tool_use_id":"call-1","content":[{"type":"text","text":"已补 3 个用例\n[Agent ID: agent-b8c88507-5a8e]"}]}]}}`)
	// The report is kept without the CLI's agent ID bookkeeping.
	if len(done) != 1 || done[0].Kind != "toolDone" || done[0].AgentID != "agent-b8c88507-5a8e" || done[0].Output != "已补 3 个用例" {
		t.Fatalf("done=%+v", done)
	}
	if plain := assistantStreamEvents(`{"type":"user","message":{"content":[{"type":"tool_result","tool_use_id":"r","content":"Agent ID: agent-x1"}]}}`); plain[0].AgentID != "agent-x1" {
		t.Fatalf("string result=%+v", plain)
	}
	// Other tool results stay out of the record.
	if other := assistantStreamEvents(`{"type":"user","message":{"content":[{"type":"tool_result","tool_use_id":"r","content":"secret file body"}]}}`); other[0].Output != "" {
		t.Fatalf("plain tool result kept: %+v", other)
	}
}

func TestActivityLogKeepsSubagentThoughtsApart(t *testing.T) {
	var log assistantActivityLog
	log.add(assistantStreamEvent{Kind: "thinking", Text: "主"})
	log.add(assistantStreamEvent{Kind: "thinking", Text: "子", Parent: "call-1"})
	log.add(assistantStreamEvent{Kind: "agentText", Text: "汇报", Parent: "call-1", Full: true})
	log.add(assistantStreamEvent{Kind: "agentText", Text: "汇报", Parent: "call-1", Full: true})
	if len(log.events) != 3 || log.events[0].Text != "主" || log.events[1].Parent != "call-1" || log.events[2].Kind != "agentText" {
		t.Fatalf("events=%+v", log.events)
	}
}

func TestRoleAgentIDsHintReuse(t *testing.T) {
	h, u := workbenchFixture(t)
	h.repo.PutAgent(domain.AgentDefinition{ID: "qa", Name: "测试工程师", ProjectID: "workbench", Prompt: "测试"})
	activity := func(id, agent string, failed bool) []domain.AssistantActivityEvent {
		return []domain.AssistantActivityEvent{{Kind: "tool", ID: id}, {Kind: "tool", ID: id, Subagent: "role-qa"}, {Kind: "toolDone", ID: id, AgentID: agent, Failed: failed}}
	}
	session := domain.AssistantSession{ID: "reuse", ProjectID: "workbench", Messages: []domain.AssistantMessage{
		{Role: "user", Content: "补单测"},
		{Role: "assistant", Content: "好", Activity: activity("c1", "agent-old", false)},
		{Role: "user", Content: "再补"},
		{Role: "assistant", Content: "好", Activity: append(activity("c2", "agent-new", false), activity("c3", "agent-broken", true)...)},
	}}
	if err := h.repo.PutAssistantSession(u.ID, session); err != nil {
		t.Fatal(err)
	}
	if ids := roleAgentIDs(session.Messages); ids["role-qa"] != "agent-new" {
		t.Fatalf("ids=%v", ids)
	}
	c, _ := workbenchContext(u, "POST", "/", bytes.NewBuffer(nil))
	req := assistantRequest{ProjectID: "workbench", SessionID: "reuse", Messages: append(session.Messages, domain.AssistantMessage{Role: "user", Content: "继续"})}
	if err := h.prepareWorkbenchContext(c, &req, u); err != nil {
		t.Fatal(err)
	}
	if !strings.Contains(req.contextText, "agent ID agent-new") || !strings.Contains(req.contextText, "resume=<agent ID>") {
		t.Fatalf("reuse hint missing: %s", req.contextText)
	}
}

// The CLI announces an Agent call with empty input before the full one; the
// stream filter must let the full copy through, or the dispatch loses its
// subagent type, task and the agent ID reuse depends on.
func TestStreamFilterKeepsCompletedAgentCall(t *testing.T) {
	var filter assistantStreamFilter
	var kept []assistantStreamEvent
	for _, line := range []string{
		`{"type":"stream_event","event":{"type":"content_block_start","content_block":{"type":"tool_use","id":"call-1","name":"Agent","input":{}}}}`,
		`{"type":"assistant","message":{"content":[{"type":"tool_use","id":"call-1","name":"Agent","input":{"subagent_type":"role-fe","description":"梳理入口","prompt":"读 chatbot/src"}}]}}`,
		`{"type":"assistant","message":{"content":[{"type":"tool_use","id":"call-1","name":"Agent","input":{"subagent_type":"role-fe","description":"梳理入口","prompt":"读 chatbot/src"}}]}}`,
	} {
		for _, ev := range assistantStreamEvents(line) {
			if filter.accept(ev) {
				kept = append(kept, ev)
			}
		}
	}
	if len(kept) != 2 {
		t.Fatalf("kept=%+v", kept)
	}
	full := kept[1]
	if full.Subagent != "role-fe" || full.Input != "读 chatbot/src" || full.Detail != "梳理入口" {
		t.Fatalf("full dispatch=%+v", full)
	}
	var log assistantActivityLog
	for _, ev := range kept {
		log.add(ev)
	}
	log.add(assistantStreamEvent{Kind: "toolDone", ID: "call-1", AgentID: "agent-1"})
	if ids := roleAgentIDs([]domain.AssistantMessage{{Role: "assistant", Activity: log.snapshot()}}); ids["role-fe"] != "agent-1" {
		t.Fatalf("reuse ids=%v", ids)
	}
}

// A subagent never sees Main Bot's system prompt, so its own file says where
// the code is and that the task outranks the role's SOP-node conventions.
func TestRoleAgentFileExplainsChatWork(t *testing.T) {
	file := roleAgentFile(roleSubagent{Role: domain.AgentDefinition{ID: "fe", Name: "前端", Prompt: "产出 brief.md 到 {{output}}"}})
	for _, want := range []string{"以 Main Bot 交给你的任务为准", "当前是平台模式", "先打开工作区并交接模式", "产出 brief.md 到 (运行时提供)"} {
		if !strings.Contains(file, want) {
			t.Fatalf("role file lacks %q:\n%s", want, file)
		}
	}
	if strings.Index(file, "在对话里工作") > strings.Index(file, "产出 brief.md") {
		t.Fatal("chat notes must come before the role prompt")
	}
	workspace := conversationRoleAgentFile(roleSubagent{Role: domain.AgentDefinition{ID: "fe", Name: "前端", Prompt: "检查文件"}}, true)
	if !strings.Contains(workspace, "同一工作区,沙箱内的文件和命令直接执行") || strings.Contains(workspace, "当前是平台模式") || !strings.Contains(workspace, "  - mcp__agentflow_session__workbench_platform_mode\n") {
		t.Fatalf("workspace subagent lacks current native tool rules:\n%s", workspace)
	}
}

// The CLI renders an agent body on the control plane, so a role prompt can
// neither run a command nor pull in a host file there.
func TestRoleAgentFileIsInert(t *testing.T) {
	file := roleAgentFile(roleSubagent{Role: domain.AgentDefinition{ID: "x", Name: "X", Prompt: "先跑 !`id`,再读 @/etc/passwd"}})
	if strings.Contains(file, "!`") || strings.Contains(file, " @/etc/passwd") {
		t.Fatalf("role file still live:\n%s", file)
	}
}

// A resumed dispatch carries its agent ID from the start, through the stream
// filter, so the panel keeps it on that agent's row while it runs.
func TestResumedDispatchNamesItsAgentUpFront(t *testing.T) {
	var filter assistantStreamFilter
	var kept []assistantStreamEvent
	for _, line := range []string{
		`{"type":"stream_event","event":{"type":"content_block_start","content_block":{"type":"tool_use","id":"call-2","name":"Agent","input":{}}}}`,
		`{"type":"assistant","message":{"content":[{"type":"tool_use","id":"call-2","name":"Agent","input":{"subagent_type":"role-fe","description":"补充","prompt":"再看样式","resume":"agent-044d4197"}}]}}`,
	} {
		for _, ev := range assistantStreamEvents(line) {
			if filter.accept(ev) {
				kept = append(kept, ev)
			}
		}
	}
	if len(kept) != 2 || kept[1].AgentID != "agent-044d4197" {
		t.Fatalf("kept=%+v", kept)
	}
	if got := assistantStreamEvents(`{"type":"assistant","message":{"content":[{"type":"tool_use","id":"c","name":"Agent","input":{"subagent_type":"role-fe","prompt":"x","resume":"not an id"}}]}}`); got[0].AgentID != "" {
		t.Fatalf("bad resume taken as ID: %+v", got)
	}
}

// Submitting the reply would end Main Bot's turn with the subagent's text,
// so a role subagent cannot reach it and hands writes back instead.
func TestRoleSubagentCannotSubmitTheReply(t *testing.T) {
	file := roleAgentFile(roleSubagent{Role: domain.AgentDefinition{ID: "x", Name: "X", Prompt: "p"}})
	front := file[:strings.Index(file[4:], "---")+4]
	if !strings.Contains(front, "disallowedTools:\n  - mcp__agentflow_session__submit_assistant_reply\n") {
		t.Fatalf("frontmatter lacks the block:\n%s", front)
	}
	if !strings.Contains(file, "不要自己提交回复或草稿") {
		t.Fatalf("notes lack the hand-back rule:\n%s", file)
	}
}

// Only Main Bot picks the workspace: while a dispatch runs, opening or
// switching one is refused whoever calls it, built-in subagents included.
func TestWorkspaceStaysWhileADispatchRuns(t *testing.T) {
	h, owner := workbenchFixture(t)
	gateway := &agentToolGateway{deps: h.deps}
	s := &AgentToolSession{Mode: AgentToolAssistant, ProjectID: "workbench", UserID: owner.ID, User: owner, ChatSessionID: "chat-1", ChatOwnerID: owner.ID}
	open := func() error {
		_, err := gateway.callMainBotWorkspace(context.Background(), s, "workbench_workspace_open", map[string]any{"sandboxProfileId": "generic-docker"})
		return err
	}
	for _, line := range []string{
		`{"type":"stream_event","event":{"type":"content_block_start","content_block":{"type":"tool_use","id":"call-1","name":"Agent","input":{}}}}`,
		`{"type":"assistant","message":{"content":[{"type":"tool_use","id":"call-1","name":"Agent","input":{"subagent_type":"general-purpose","prompt":"x"}}]}}`,
	} {
		for _, ev := range assistantStreamEvents(line) {
			s.trackDispatch(ev)
		}
	}
	// The subagent's own calls carry a parent and never count as dispatches.
	s.trackDispatch(assistantStreamEvent{Kind: "toolDone", ID: "inner", Parent: "call-1"})
	if err := open(); err == nil || !strings.Contains(err.Error(), "子 Agent 运行期间") {
		t.Fatalf("open during a dispatch must be refused: %v", err)
	}
	for _, ev := range assistantStreamEvents(`{"type":"user","message":{"content":[{"type":"tool_result","tool_use_id":"call-1","content":"done\nAgent ID: agent-1"}]}}`) {
		s.trackDispatch(ev)
	}
	if err := open(); err != nil && strings.Contains(err.Error(), "子 Agent 运行期间") {
		t.Fatalf("open after the dispatch must go through: %v", err)
	}
	if file := roleAgentFile(roleSubagent{Role: domain.AgentDefinition{ID: "x", Name: "X", Prompt: "p"}}); !strings.Contains(file, "  - mcp__agentflow_session__workbench_workspace_open\n") {
		t.Fatalf("role file must block workspace_open:\n%s", file)
	}
}

// A finished role dispatch is collected like an SOP node: the files its
// artifactOutputs name are attached to the reply, past the per-turn cap, and
// a required one that is missing becomes a failed step under the dispatch.
func TestRoleDeliverablesAreCollectedWhenTheDispatchEnds(t *testing.T) {
	hostConversationWorkspace(t)
	h, owner := workbenchFixture(t)
	configureConversationSandbox(t, h)
	if err := h.repo.PutRepository(domain.Repository{ID: "repo-web", ProjectID: "workbench", Name: "web", LocalPath: gitRepo(t), DefaultBranch: "main"}); err != nil {
		t.Fatal(err)
	}
	if err := h.repo.PutAssistantSession(owner.ID, domain.AssistantSession{ID: "chat-d", ProjectID: "workbench", Messages: []domain.AssistantMessage{{Role: "user", Content: "归档"}}}); err != nil {
		t.Fatal(err)
	}
	en := engine.New(h.repo, runtime.NewManager(t.TempDir()))
	h.deps.engine = en
	gateway := &agentToolGateway{deps: h.deps}
	gateway.api = New(h.repo, en, tracker.NewService(), "", "")
	s := &AgentToolSession{Mode: AgentToolAssistant, ProjectID: "workbench", UserID: owner.ID, User: owner, ChatSessionID: "chat-d", ChatOwnerID: owner.ID}
	if _, err := gateway.callMainBotWorkspace(context.Background(), s, "workbench_workspace_open", map[string]any{}); err != nil {
		t.Fatal(err)
	}
	if err := workspaceTestEdit(context.Background(), gateway, s, "archive.md", "# 归档\n"); err != nil {
		t.Fatal(err)
	}
	for i := 0; i < agentReplyFileLimit; i++ {
		if err := s.attachReplyFile(fmt.Sprintf("main-%d.md", i), "text/markdown", []byte("x")); err != nil {
			t.Fatal(err)
		}
	}
	roles := []roleSubagent{{Role: domain.AgentDefinition{ID: "archiver", Name: "归档", ArtifactOutputs: []domain.ArtifactContract{
		{Name: "archive", Path: "archive.md", Required: true},
		{Name: "plan", Path: "plan.md"},
		{Name: "review", Path: "review.md", Required: true},
		{Name: "escape", Path: "../secret.md", Required: true},
	}}}}

	// Only a dispatch the stream saw finish is collected.
	s.trackDispatch(assistantStreamEvent{Kind: "tool", Tool: "Agent", ID: "call-a", Subagent: "role-archiver"})
	finished := s.trackDispatch(assistantStreamEvent{Kind: "toolDone", ID: "call-a"})
	events := h.collectRoleDeliverables(context.Background(), s, "call-a", finished, roles)

	var steps []string
	for _, ev := range events {
		if ev.Parent != "call-a" {
			t.Fatalf("deliverable step outside its dispatch: %+v", ev)
		}
		if ev.Kind == "tool" {
			steps = append(steps, ev.Text)
		}
	}
	if strings.Join(steps, "|") != "已收集交付物 · archive.md|缺少必需交付物 · review.md" {
		t.Fatalf("steps=%v", steps)
	}
	if events[len(events)-1].Kind != "toolDone" || !events[len(events)-1].Failed {
		t.Fatalf("missing required file must fail: %+v", events[len(events)-1])
	}
	var archived bool
	for _, f := range s.takeReplyFiles() {
		archived = archived || (f.Name == "archive.md" && string(f.Data) == "# 归档\n")
	}
	if !archived {
		t.Fatal("archive.md was not attached past the per-turn cap")
	}
	if got := h.collectRoleDeliverables(context.Background(), s, "call-b", "general-purpose", roles); got != nil {
		t.Fatalf("non-role dispatch collected: %+v", got)
	}
}