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.
JavaScript agent-orchestrationagentic-workflowai-agentsai-codingclaude-codecode-reviewcodebuddycodexcoding-agentscursordeveloper-toolshuman-on-the-loopllmmcpmulti-agentsdlcself-hostedsopworkflow-automationworkflow-engine
package engine
import (
"context"
"errors"
"os"
"os/exec"
"path/filepath"
"strings"
"testing"
"time"
"agentflow/internal/domain"
"agentflow/internal/observability"
"agentflow/internal/runtime"
)
func TestIntegrationLabelsRepairAndPatchInventoryBranches(t *testing.T) {
run := domain.Run{ID: "run", Input: strings.Repeat("题", 80) + "\nrest", ExecutionContext: domain.TelemetryContext{IssueNumber: 42}, Repository: domain.RepositoryContext{WorkBranch: "feature/work"}}
if got := integrationCommitLabel(run); !strings.HasPrefix(got, "issue #42 ") || len([]rune(got)) > 82 {
t.Fatalf("label=%q", got)
}
noTitle := run
noTitle.Input = ""
if integrationCommitLabel(noTitle) != "issue #42" {
t.Fatal("issue-only label")
}
branch := domain.Run{Repository: domain.RepositoryContext{WorkBranch: "feature/x"}}
if integrationCommitLabel(branch) != "feature/x" || integrationCommitLabel(domain.Run{}) != "scheduled SOP work" {
t.Fatal("fallback labels")
}
if title := integrateMRTitle(run, domain.RepositoryContext{AlignOnly: true, DefaultBranch: "main"}, "work", "integration"); !strings.Contains(title, "main") {
t.Fatalf("align title=%q", title)
}
if title := integrateMRTitle(domain.Run{}, domain.RepositoryContext{}, "work", "integration"); !strings.Contains(title, "work") {
t.Fatalf("generic title=%q", title)
}
if title := integrateMRTitle(run, domain.RepositoryContext{}, "work", "integration"); !strings.Contains(title, "issue #42") {
t.Fatalf("issue title=%q", title)
}
if description := integrateMRDescription(domain.Run{ID: "align", Repository: domain.RepositoryContext{AlignOnly: true}}, "main", "integration"); !strings.Contains(description, "Align") {
t.Fatalf("align description=%q", description)
}
if description := integrateMRDescription(run, "work", "integration"); !strings.Contains(description, "issue: #42") {
t.Fatalf("issue description=%q", description)
}
workflow := domain.WorkflowDefinition{Nodes: []domain.WorkflowNode{{ID: "writer", Type: "agent"}, {ID: "review", Type: "agent", RejectTo: "writer"}}}
if integrationRepairNode(workflow) != "writer" {
t.Fatal("reject target repair node")
}
if integrationRepairNode(domain.WorkflowDefinition{Nodes: []domain.WorkflowNode{{ID: "implementation", Type: "agent"}}}) != "implementation" {
t.Fatal("named repair node")
}
if integrationRepairNode(domain.WorkflowDefinition{Nodes: []domain.WorkflowNode{{ID: "other", Type: "agent"}}}) != "other" {
t.Fatal("first agent repair node")
}
if integrationRepairNode(domain.WorkflowDefinition{}) != "" {
t.Fatal("empty workflow repair node")
}
if files := patchNewFiles("A\tone.go\nM\ttwo.go\nA\tthree.go"); len(files) != 2 {
t.Fatalf("name-status files=%v", files)
}
diff := "diff --git a/new.go b/new.go\nnew file mode 100644\n--- /dev/null\n+++ b/new.go\n@@ -0,0 +1 @@\n+package new\n"
if files := patchNewFiles(diff); len(files) != 1 || files[0] != "new.go" {
t.Fatalf("diff files=%v", files)
}
workspace := t.TempDir()
if out, err := os.Create(filepath.Join(workspace, "not-a-repo")); err != nil {
t.Fatal(err)
} else {
_ = out.Close()
}
artifactRun := domain.Run{Artifacts: []domain.Artifact{{Name: "repository-patch", NodeID: "writer", Content: "A\tmissing.go"}}}
if missing := (&Engine{}).verifyDeliveryCompleteness(artifactRun, workspace); len(missing) != 0 {
t.Fatalf("non-git completeness=%v", missing)
}
}
func TestObservabilityFilteringCoalescingAndFormattingBranches(t *testing.T) {
base := domain.TelemetryEvent{Name: "event", Category: "process", Phase: "finish"}
if attrs := logAttributes(base); len(attrs) != 3 {
t.Fatalf("base attrs=%v", attrs)
}
base.Attributes = map[string]any{"input": "x", "status": nil, "ignored": true}
if attrs := logAttributes(base); attrs["input"] != "x" {
t.Fatalf("attrs=%v", attrs)
}
for _, event := range []domain.TelemetryEvent{
{Source: domain.TelemetrySource{Adapter: observability.AdapterHooks}, Message: "x"},
{Source: domain.TelemetrySource{Adapter: observability.AdapterOTEL}, Message: "x"},
{Category: "reasoning", Message: "x"},
{Category: "usage", Message: "x"},
{Category: "output", Name: "text.delta", Message: "x"},
{Category: "model", Name: "model.request", Message: "x"},
{Category: "tool", Phase: "finish", Message: "x"},
{Message: ""},
} {
if shouldRecordLog(event) {
t.Fatalf("noisy event recorded: %+v", event)
}
}
if !shouldRecordLog(domain.TelemetryEvent{Category: "process", Message: "useful"}) {
t.Fatal("useful event dropped")
}
if isNoisyWorkerLog(domain.TelemetryEvent{Level: "error", Category: "tool", Phase: "finish"}) {
t.Fatal("error log marked noisy")
}
for _, message := range []string{"工具完成", "工具完成 Bash", "Bash 完成", "Read 结果: ok"} {
if !toolCompletionMessage(message) {
t.Fatalf("completion not detected: %q", message)
}
}
for _, message := range []string{"", "ordinary message", "中文 完成"} {
if toolCompletionMessage(message) {
t.Fatalf("false completion: %q", message)
}
}
if !looksLikeToolName("mcp/tool-1") || looksLikeToolName(strings.Repeat("a", 65)) || looksLikeToolName("工具") {
t.Fatal("tool name validation")
}
long := strings.Repeat("x", 64*1024+1)
if got := boundedLogBody(long); !strings.Contains(got, "truncated") {
t.Fatal("long log not bounded")
}
if boundedLogBody("short") != "short" {
t.Fatal("short log changed")
}
events := []domain.TelemetryEvent{{NodeID: "node", Category: "output", Name: "text", Phase: "progress", Message: "a", Sequence: 1}}
if !coalesceProgressTelemetry(&events, domain.TelemetryEvent{NodeID: "node", Category: "output", Name: "text", Phase: "progress", Message: "b", Sequence: 2}) || events[0].Message != "ab" {
t.Fatalf("coalesced=%v", events)
}
if coalesceProgressTelemetry(&events, domain.TelemetryEvent{NodeID: "other", Category: "output", Name: "text", Phase: "progress", Message: "x"}) {
t.Fatal("cross-node telemetry coalesced")
}
if coalesceProgressTelemetry(&events, domain.TelemetryEvent{NodeID: "node", Category: "usage", Phase: "progress", Message: "x"}) {
t.Fatal("usage telemetry coalesced")
}
if got := compactProgressText(strings.Repeat("界", maxTelemetryProgressRunes+10)); !strings.Contains(got, "stream truncated") {
t.Fatal("progress not compacted")
}
run := domain.Run{ID: "run"}
appendControlTelemetry(&run, "node", "approved", "ok")
if run.TelemetrySequence != 1 || len(run.Telemetry) != 1 {
t.Fatalf("control telemetry=%v", run.Telemetry)
}
}
func TestRepositoryPatchParsingAndGateResultErrors(t *testing.T) {
diff := "diff --git a/old.txt b/new.txt\nsimilarity index 100%\nrename from old.txt\nrename to new.txt\ndiff --git a/add.txt b/add.txt\nnew file mode 100644\n--- /dev/null\n+++ b/add.txt\n@@ -0,0 +1 @@\n+x\n"
files := parseUnifiedDiffFiles([]byte(diff))
if len(files) != 2 {
t.Fatalf("parsed files=%+v", files)
}
if summary := summarizeRepositoryPatch([]byte(diff)); !strings.Contains(summary, "add.txt") {
t.Fatalf("summary=%q", summary)
}
if left, right := splitGitDiffHeader(`diff --git a/file-one b/file-one`); left == "" || right == "" {
t.Fatalf("split=%q %q", left, right)
}
if left, right := splitGitDiffHeader("invalid"); left != "" || right != "" {
t.Fatal("invalid diff header split")
}
workspace := t.TempDir()
if result, err := readGateResultFrom(workspaceOutputs(workspace), "missing"); err != nil || result != nil {
t.Fatalf("missing gate result=%v err=%v", result, err)
}
if err := os.WriteFile(filepath.Join(workspace, "gate.json"), []byte("{"), 0o644); err != nil {
t.Fatal(err)
}
if _, err := readGateResultFrom(workspaceOutputs(workspace), "gate.json"); err == nil {
t.Fatal("invalid gate JSON accepted")
}
if formatElapsedCN(2*time.Hour) != "120 分钟" {
t.Fatal("long elapsed formatting")
}
}
func TestObservationQueuesRunStateAndFlushLoopBranches(t *testing.T) {
var nilEngine *Engine
nilEngine.enqueueObservation("run", "node", domain.TelemetryEvent{})
nilEngine.signalObservationFlush()
nilEngine.flushAllObservations()
nilEngine.observationFlushLoop(context.Background())
e, _ := cvEEngine(t)
e.obsPending = []pendingObservation{
{runID: "one", nodeID: "a"},
{runID: "one", nodeID: "b"},
{runID: "two", nodeID: "c"},
}
if ids := e.pendingObservationRunIDs(); len(ids) != 2 {
t.Fatalf("pending ids=%v", ids)
}
if taken := e.takePendingObservations("one"); len(taken) != 2 || len(e.obsPending) != 1 {
t.Fatalf("taken=%v kept=%v", taken, e.obsPending)
}
if taken := e.takePendingObservations("missing"); len(taken) != 0 {
t.Fatalf("unexpected observations=%v", taken)
}
e.obsKick = make(chan struct{}, 1)
e.signalObservationFlush()
e.signalObservationFlush()
ctx, cancel := context.WithCancel(context.Background())
cancel()
e.observationFlushLoop(ctx)
if e.updateRunAt("missing", false, nil) {
t.Fatal("missing run update succeeded")
}
if updated, err := e.updateRunAtErr("missing", false, nil); updated || err != nil {
t.Fatalf("missing run update returned updated=%t, err=%v", updated, err)
}
if _, _, err := e.Subscribe("missing"); err == nil {
t.Fatal("missing subscription succeeded")
}
stop := make(chan struct{})
close(stop)
e.pollRun("missing", stop, 0)
e.publish("missing")
ch := make(chan domain.Run, 1)
ch <- domain.Run{ID: "old"}
e.subs["stream"] = map[chan domain.Run]struct{}{ch: {}}
e.publishRun(domain.Run{ID: "stream", Revision: 2})
if got := <-ch; got.Revision != 2 {
t.Fatalf("published=%+v", got)
}
run := domain.Run{ID: "terminal", Status: "succeeded", Nodes: map[string]*domain.NodeRun{}}
e.applyObservation(&run, "", domain.TelemetryEvent{Name: "ignored"})
if len(run.Telemetry) != 0 {
t.Fatal("terminal observation applied")
}
e.applyObservation(&run, "", domain.TelemetryEvent{Name: "sandbox.closed", Message: "closed"})
if len(run.Telemetry) != 1 {
t.Fatal("sandbox close observation missing")
}
}
func TestNodeOutcomeDecisionAndTransitionBranches(t *testing.T) {
run := domain.Run{Generation: 2}
nodeRun := &domain.NodeRun{Status: "running", Attempt: 3}
if shouldCommitNodeOutcome(run, nodeRun, 1, 3, true) || shouldCommitNodeOutcome(run, nil, 2, 3, true) {
t.Fatal("stale outcome accepted")
}
nodeRun.Status = "succeeded"
if shouldCommitNodeOutcome(run, nodeRun, 2, 3, true) {
t.Fatal("completed outcome accepted")
}
nodeRun.Status = "running"
if !shouldCommitNodeOutcome(run, nodeRun, 2, 9, true) || shouldCommitNodeOutcome(run, nodeRun, 2, 2, false) || !shouldCommitNodeOutcome(run, nodeRun, 2, 3, false) {
t.Fatal("attempt outcome fencing")
}
if shouldRetryFailedAttempt(domain.WorkflowNode{MaxAttempts: 3}, 1, ErrWorkspaceControlConfiguration) {
t.Fatal("configuration failure retried")
}
if shouldRetryFailedAttempt(domain.WorkflowNode{MaxAttempts: 3}, 1, runtime.ErrMaxTurns) {
t.Fatal("max turns retried")
}
if shouldRetryFailedAttempt(domain.WorkflowNode{MaxAttempts: 3}, 1, errors.New("verification failed")) {
t.Fatal("verification failure retried")
}
if !shouldRetryFailedAttempt(domain.WorkflowNode{MaxAttempts: 3}, 1, errors.New("ordinary")) {
t.Fatal("ordinary failure not retried")
}
nodeRun.GateResult = &domain.GateResult{Decision: " ReWork "}
if !gateReworkReject(true, nodeRun) || gateReworkReject(false, nodeRun) || gateReworkReject(true, nil) {
t.Fatal("gate rework decision")
}
if resolveGateOnFailure("invalid", " HUMAN ") != "human" || resolveGateOnFailure("", "") != "fail" {
t.Fatal("gate failure resolution")
}
if !isMaxTurnsErr(errors.New("executor reached max turns")) || isMaxTurnsErr(nil) {
t.Fatal("max-turn detection")
}
script := domain.WorkflowNode{Type: "script", RejectTo: "upstream"}
if !nodeRejects(script) || !allowRejectOnFailure(script, errors.New("boom"), false) || allowRejectOnFailure(domain.WorkflowNode{}, errors.New("boom"), false) {
t.Fatal("reject-on-failure decision")
}
agent := domain.WorkflowNode{Type: "agent", RejectTo: "upstream"}
if !allowRejectOnFailure(agent, nil, true) || allowRejectOnFailure(agent, errors.New("without a terminal result"), false) || allowRejectOnFailure(agent, runtime.ErrMaxTurns, false) || !allowRejectOnFailure(agent, errors.New("verification gate failed"), false) {
t.Fatal("agent reject-on-failure decision")
}
merged := mergeArtifactContracts(
[]domain.ArtifactContract{{Name: "same", Path: "old"}, {Path: "path-only"}},
[]domain.ArtifactContract{{Name: "same", Path: "new"}},
)
if len(merged) != 2 || merged[0].Path != "new" {
t.Fatalf("merged contracts=%v", merged)
}
e, st := cvEEngine(t)
e.mu.Lock()
e.executeRuns = false
e.mu.Unlock()
closedIssue := domain.Issue{
ID: "closed-gongfeng-more", ProjectID: "platform", Title: "Closed", Source: "gongfeng",
ExternalRef: &domain.ExternalRef{ExternalState: "closed"},
}
if err := st.PutIssue(closedIssue); err != nil {
t.Fatal(err)
}
if !errors.Is(forbidClosedGongfengIssue(st, domain.Run{ExecutionContext: domain.TelemetryContext{IssueID: closedIssue.ID}}), errGongfengIssueClosed) {
t.Fatal("closed Gongfeng issue accepted")
}
if err := forbidClosedGongfengIssue(st, domain.Run{ExecutionContext: domain.TelemetryContext{IssueID: "missing"}}); err != nil {
t.Fatal(err)
}
for _, tc := range []struct {
id, typ string
pause bool
want string
}{
{id: "cancel-node", typ: "agent", want: "cancelled"},
{id: "pause-agent", typ: "agent", pause: true, want: "waiting_approval"},
{id: "pause-script", typ: "script", pause: true, want: "waiting_approval"},
} {
stored := domain.Run{ID: tc.id, Status: "running", PauseRequested: tc.pause, Nodes: map[string]*domain.NodeRun{"node": {NodeID: "node", Status: "running"}}}
if err := st.PutRun(stored); err != nil {
t.Fatal(err)
}
e.nodeCancelled(tc.id, domain.WorkflowNode{ID: "node", Name: "Node", Type: tc.typ})
got, _ := st.RunState(tc.id)
if got.Nodes["node"].Status != tc.want {
t.Fatalf("%s node=%+v", tc.id, got.Nodes["node"])
}
}
interrupted := domain.Run{ID: "interrupted-node", Status: "running", Generation: 0, Nodes: map[string]*domain.NodeRun{"node": {NodeID: "node", Status: "running", Attempt: 2}}}
if err := st.PutRun(interrupted); err != nil {
t.Fatal(err)
}
e.requeueInterruptedNode(interrupted.ID, "node", 2, 0)
interruptedGot, _ := st.RunState(interrupted.ID)
if interruptedGot.Nodes["node"].Status != "pending" {
t.Fatalf("interrupted node=%+v", interruptedGot.Nodes["node"])
}
}
func TestRepositoryPatchRunnerQueueAndArtifactBranches(t *testing.T) {
workspace := t.TempDir()
for _, args := range [][]string{{"init", "-q"}, {"config", "user.email", "[email protected]"}, {"config", "user.name", "Test"}} {
if out, err := exec.Command("git", append([]string{"-C", workspace}, args...)...).CombinedOutput(); err != nil {
t.Fatalf("git %v: %v: %s", args, err, out)
}
}
if err := os.WriteFile(filepath.Join(workspace, "base.txt"), []byte("old\n"), 0o644); err != nil {
t.Fatal(err)
}
if out, err := exec.Command("git", "-C", workspace, "add", ".").CombinedOutput(); err != nil {
t.Fatalf("git add: %v: %s", err, out)
}
if out, err := exec.Command("git", "-C", workspace, "commit", "-qm", "base").CombinedOutput(); err != nil {
t.Fatalf("git commit: %v: %s", err, out)
}
patch := "diff --git a/base.txt b/base.txt\n--- a/base.txt\n+++ b/base.txt\n@@ -1 +1 @@\n-old\n+new\n"
if err := applyRepositoryPatch(workspace, patch); err != nil {
t.Fatal(err)
}
if data, _ := os.ReadFile(filepath.Join(workspace, "base.txt")); string(data) != "new\n" {
t.Fatalf("patched content=%q", data)
}
if err := applyRepositoryPatch(workspace, "not a patch"); err != nil {
t.Fatal(err)
}
if err := applyRepositoryPatch(workspace, patch); err == nil {
t.Fatal("duplicate patch unexpectedly applied")
}
artifactRoot := t.TempDir()
contracts := []domain.ArtifactContract{{Name: "result", Path: "nested/result.txt"}, {Name: "ignored"}}
if err := restoreRunnerArtifacts(artifactRoot, contracts, map[string]string{"result": "ok", "unknown": "skip", "ignored": "skip"}); err != nil {
t.Fatal(err)
}
if data, err := os.ReadFile(filepath.Join(artifactRoot, "nested", "result.txt")); err != nil || string(data) != "ok" {
t.Fatalf("restored artifact=%q err=%v", data, err)
}
if err := restoreRunnerArtifacts(artifactRoot, nil, map[string]string{"x": "x"}); err != nil {
t.Fatal(err)
}
blocked := filepath.Join(t.TempDir(), "file")
if err := os.WriteFile(blocked, []byte("x"), 0o644); err != nil {
t.Fatal(err)
}
if err := restoreRunnerArtifacts(blocked, []domain.ArtifactContract{{Name: "x", Path: "child/out"}}, map[string]string{"x": "x"}); err == nil {
t.Fatal("artifact under file unexpectedly restored")
}
e, st := cvEEngine(t)
var notified []string
e.SetRunnerDispatchNotify(func(provider string) { notified = append(notified, provider) })
runner := cvERunner(t, e, "queue-runner-more", domain.RunnerStatusOnline, "terminal")
run := cvERunnerRun("queue-run-more", runner.ID)
if err := st.PutRun(run); err != nil {
t.Fatal(err)
}
if err := e.queueRunnerRunCleanup(run); err != nil {
t.Fatal(err)
}
if err := e.queueRunnerRunCleanup(run); err != nil {
t.Fatal(err)
}
if task, ok := st.RunnerTask("rt-cleanup-" + safeRunnerPath(run.ID)); !ok || task.Action != domain.RunnerTaskActionCleanupRun {
t.Fatalf("cleanup task=%+v ok=%v", task, ok)
}
if err := e.queueRunnerPreviewArchive(run, domain.RunnerPreviewArchiveSpec{}); err != nil {
t.Fatal(err)
}
if err := e.queueRunnerPreviewArchive(run, domain.RunnerPreviewArchiveSpec{}); err != nil {
t.Fatal(err)
}
if len(notified) != 2 {
t.Fatalf("dispatch notifications=%v", notified)
}
noRunner := cvERunnerRun("no-runner-more", "")
if err := e.queueRunnerRunCleanup(noRunner); err != nil {
t.Fatal(err)
}
if err := e.queueRunnerPreviewArchive(noRunner, domain.RunnerPreviewArchiveSpec{}); err == nil {
t.Fatal("preview archive without runner accepted")
}
missingRunner := cvERunnerRun("missing-runner-more", "gone")
if err := e.queueRunnerRunCleanup(missingRunner); err != nil {
t.Fatal(err)
}
if err := e.queueRunnerPreviewArchive(missingRunner, domain.RunnerPreviewArchiveSpec{}); err == nil {
t.Fatal("preview archive missing runner accepted")
}
if err := e.requireRunnerProvider("missing", "terminal"); err == nil {
t.Fatal("missing provider runner accepted")
}
runner.Status = domain.RunnerStatusOffline
if err := st.PutRunner(runner); err != nil {
t.Fatal(err)
}
if err := e.requireRunnerProvider(runner.ID, "terminal"); err == nil {
t.Fatal("offline runner accepted")
}
runner.Status = domain.RunnerStatusOnline
runner.Runtimes = nil
if err := st.PutRunner(runner); err != nil {
t.Fatal(err)
}
if err := e.requireRunnerProvider(runner.ID, "terminal"); err == nil {
t.Fatal("unsupported provider accepted")
}
runner.Runtimes = []domain.RunnerRuntime{{Provider: "terminal", Status: "ready", AuthMode: domain.RuntimeAuthLocal}}
if err := st.PutRunner(runner); err != nil {
t.Fatal(err)
}
if err := e.requireRunnerProvider(runner.ID, "terminal"); err != nil {
t.Fatal(err)
}
done := domain.RunnerTask{ID: "await-done-more", RunnerID: runner.ID, Provider: "terminal", Status: domain.RunnerTaskSuccess}
if err := st.PutRunnerTask(done); err != nil {
t.Fatal(err)
}
if got, err := e.awaitRunnerTask(context.Background(), done.ID, func(domain.TelemetryEvent) {}); err != nil || got.Status != domain.RunnerTaskSuccess {
t.Fatalf("await task=%+v err=%v", got, err)
}
if _, err := e.awaitRunnerTask(context.Background(), "missing-task-more", nil); err == nil {
t.Fatal("missing awaited task accepted")
}
pending := domain.RunnerTask{ID: "await-cancel-more", RunnerID: runner.ID, Provider: "terminal", Status: domain.RunnerTaskLeased}
if err := st.PutRunnerTask(pending); err != nil {
t.Fatal(err)
}
cancelCtx, cancel := context.WithCancel(context.Background())
cancel()
var statusEvents int
if _, err := e.awaitRunnerTask(cancelCtx, pending.ID, func(domain.TelemetryEvent) { statusEvents++ }); !errors.Is(err, context.Canceled) {
t.Fatalf("canceled await err=%v", err)
}
if statusEvents == 0 {
t.Fatal("leased runner status was not reported")
}
}
func TestPromptObservabilityAlignAndResumeRemainingBranches(t *testing.T) {
node := domain.WorkflowNode{ID: "review", RejectTo: "writer"}
role := &domain.AgentDefinition{Name: "评审", Prompt: "{{pipelineUrl}}\n{{humanContext}}\n{{feedback}}"}
run := domain.Run{
Input: "input",
HumanContext: "human note",
Repository: domain.RepositoryContext{
RepositoryID: "repo", Name: "Repo", PipelineURLPattern: "https://ci/{build_id}",
},
Nodes: map[string]*domain.NodeRun{"review": {Feedback: "fix"}},
}
prompt := applyPromptPlaceholders(nil, domain.WorkflowDefinition{ID: "issue-flow"}, node, role, run)
if !strings.Contains(prompt, "https://ci/current") || !strings.Contains(prompt, "人工补充上下文") {
t.Fatalf("prompt=%q", prompt)
}
run.Repository.PipelineURLPattern = ""
run.Repository.PipelineProjectID, run.Repository.PipelineDefID = 12, 34
if prompt = applyPromptPlaceholders(nil, domain.WorkflowDefinition{}, node, role, run); !strings.Contains(prompt, "未配置 Pipeline") {
t.Fatalf("pipeline prompt=%q", prompt)
}
continued := domain.Run{
Repository: domain.RepositoryContext{RepositoryID: "repo", Name: "Repo", RequireExistingWorkBranch: true, WorkBranch: "feature", BaseBranch: "main"},
Artifacts: []domain.Artifact{{NodeID: "mr", Name: "mr-body", Content: "merge_requests/1"}},
}
if blurb := existingMRBlurb(nil, continued); !strings.Contains(blurb, "merge_requests/1") {
t.Fatalf("continued MR=%q", blurb)
}
longMR := domain.Run{Artifacts: []domain.Artifact{
{NodeID: "mr", Name: "mr-body", Attempt: 1, CreatedAt: time.Now().Add(-time.Hour), Content: "merge_requests/old"},
{NodeID: "mr", Name: "mr-body", Attempt: 1, CreatedAt: time.Now(), Content: "merge_requests/" + strings.Repeat("x", 3000)},
}}
if blurb := existingMRBlurb(nil, longMR); !strings.Contains(blurb, "…") || strings.Contains(blurb, "old") {
t.Fatalf("latest clipped MR=%q", blurb)
}
var event *domain.TelemetryEvent
clarifyProcessLog(event)
r := domain.Run{}
nr := domain.NodeRun{SessionID: "session"}
applyUsage(nil, &nr, "", domain.TokenUsage{})
applyUsage(&r, nil, "", domain.TokenUsage{})
applyUsage(&r, &nr, "", domain.TokenUsage{CostStatus: "known"})
if nr.UsageCursor.CostStatus != "known" {
t.Fatalf("usage cursor=%+v", nr.UsageCursor)
}
telemetry := []domain.TelemetryEvent{
{NodeID: "node", Name: "agent.completed"},
{NodeID: "node", Category: "process", Name: "process.finished", Source: domain.TelemetrySource{Layer: "executor"}},
{NodeID: "node", Category: "verification", Name: "process.finished"},
{NodeID: "node", Category: "verification", Name: "process.finished", Level: "error"},
{NodeID: "node", Name: "agent.loop", Message: "again"},
{NodeID: "node", Category: "tool", Name: "tool.call", Phase: "finish"},
}
retroRun := domain.Run{Telemetry: telemetry}
for _, tc := range []struct {
err error
strategy string
}{
{errors.New("without a terminal result"), "loop"},
{errors.New("No such file"), "reject"},
{errors.New("ordinary"), "fail"},
{errors.New("ordinary"), "human"},
{nil, ""},
} {
if got := buildLoopRetro(retroRun, "node", 2, tc.err, tc.strategy); !strings.Contains(got, "Loop 复盘") {
t.Fatalf("retro=%q", got)
}
}
missingResult := domain.Run{Telemetry: []domain.TelemetryEvent{{NodeID: "node", Category: "process", Name: "process.finished", Source: domain.TelemetrySource{Layer: "executor"}}}}
_ = buildLoopRetro(missingResult, "node", 1, errors.New("without a terminal result"), "loop")
_ = buildLoopRetro(missingResult, "node", 1, errors.New("ordinary"), "loop")
align := domain.Run{
Repositories: []domain.RepositoryContext{{AlignOnly: true}},
WorkflowSnapshot: domain.WorkflowDefinition{Nodes: []domain.WorkflowNode{
{ID: "missing", Type: "approval"}, {ID: "done", Type: "approval"}, {ID: "wait", Type: "approval"},
}},
Nodes: map[string]*domain.NodeRun{"done": {Status: "succeeded"}, "wait": {Status: "waiting_approval"}},
}
if !alignOnlyRun(align) || !alignRunWaitingApproval(align) {
t.Fatal("align-only run not recognized")
}
if !autoSucceedAlignApprovals(&align, time.Now()) || align.Nodes["wait"].Status != "succeeded" {
t.Fatal("align approval not completed")
}
if alignRunWaitingApproval(align) {
t.Fatal("completed align still waiting")
}
if (&AlignConflictError{Integrate: "i", Default: "d"}).Error() == "" {
t.Fatal("empty conflict error")
}
if (&AlignConflictError{}).RenderBlocks() != "" {
t.Fatal("empty blocks rendered")
}
if ShouldAlignIntegrate(domain.RepositoryContext{IntegrateBranch: "main", DefaultBranch: "main"}) {
t.Fatal("equal branches require alignment")
}
if got := resumeNodeID(domain.Run{Nodes: map[string]*domain.NodeRun{"failed": {Status: "failed"}}}); got != "failed" {
t.Fatalf("unordered failed resume=%q", got)
}
wf := domain.WorkflowDefinition{Nodes: []domain.WorkflowNode{{ID: "a"}, {ID: "b"}}, Edges: []domain.WorkflowEdge{{Source: "a", Target: "b"}}}
if got := resumeNodeID(domain.Run{WorkflowSnapshot: wf, Nodes: map[string]*domain.NodeRun{"a": {Status: "succeeded"}, "b": {Status: "pending"}}}); got != "b" {
t.Fatalf("ready resume=%q", got)
}
if got := resumeNodeID(domain.Run{WorkflowSnapshot: wf, Nodes: map[string]*domain.NodeRun{"a": {Status: "running"}, "b": {Status: "pending"}}}); got != "a" {
t.Fatalf("fallback resume=%q", got)
}
}