feat(work): materialize durable solution waves
CI / test (push) Successful in 1m7s
CI / test (pull_request) Successful in 44s

This commit is contained in:
m
2026-08-23 16:56:58 +03:00
parent 89694047b1
commit 09d53adfd1
8 changed files with 162 additions and 4 deletions
+29
View File
@@ -1,10 +1,39 @@
package application
import (
"context"
"git.cin.su/m/Assistant/contracts/work"
"git.cin.su/m/Assistant/modules/work/domain"
"git.cin.su/m/Assistant/modules/work/ports"
"time"
)
func DecideSolutionSearch(input work.SolutionSearchInput) (work.SolutionSearchDecision, error) {
return domain.DecideSolutionSearch(input)
}
func OrchestrateSolutionSearch(ctx context.Context, store ports.GraphStore, request work.SolutionSearchWaveRequest) (work.SolutionSearchWaveResult, error) {
decision, err := domain.DecideSolutionSearch(request.Input)
if err != nil {
return work.SolutionSearchWaveResult{}, err
}
result := work.SolutionSearchWaveResult{Decision: decision}
if !decision.ContinueSearching || decision.State == work.OrchestrationExecuting {
return result, nil
}
graph, intents, err := domain.BuildSolutionSearchWave(decision, request)
if err != nil {
return work.SolutionSearchWaveResult{}, err
}
if request.NowUnixMillis < 1 {
request.NowUnixMillis = time.Now().UnixMilli()
}
graph, ready, err := AdmitAndSchedule(ctx, store, GraphScheduleRequest{Graph: graph, Intents: intents, Now: request.NowUnixMillis})
if err != nil {
return work.SolutionSearchWaveResult{}, err
}
result.Graph = graph
result.ScheduledNodeIDs = ready
result.GraphMaterialized = true
return result, nil
}
+40
View File
@@ -2,6 +2,7 @@ package domain
import (
"errors"
"fmt"
"git.cin.su/m/Assistant/contracts/work"
)
@@ -49,3 +50,42 @@ func DecideSolutionSearch(input work.SolutionSearchInput) (work.SolutionSearchDe
}
return decision, nil
}
var ErrInvalidSolutionSearchWave = errors.New("invalid solution search wave")
// BuildSolutionSearchWave turns a policy decision into a durable Work Graph
// fan-out. Human attention remains in the decision but is not an agent dispatch.
func BuildSolutionSearchWave(decision work.SolutionSearchDecision, request work.SolutionSearchWaveRequest) (work.WorkGraph, []work.AgentDispatchIntent, error) {
if !decision.ContinueSearching || (decision.State != work.OrchestrationSearching && decision.State != work.OrchestrationWaiting) || request.GraphID == "" || request.IdempotencyPrefix == "" || request.Budget.MaxParallel < 1 || request.Budget.MaxAttempts < 1 {
return work.WorkGraph{}, nil, ErrInvalidSolutionSearchWave
}
seen := make(map[work.SearchOptionKind]struct{}, len(request.Dispatches))
nodes := make([]work.GraphNode, 0, len(request.Dispatches))
intents := make([]work.AgentDispatchIntent, 0, len(request.Dispatches))
for index, dispatch := range request.Dispatches {
if dispatch.Option == work.SearchOptionHuman || dispatch.Option == "" || dispatch.Intent.DispatchID == "" || dispatch.Intent.IdempotencyKey == "" {
return work.WorkGraph{}, nil, ErrInvalidSolutionSearchWave
}
if _, exists := seen[dispatch.Option]; exists || !containsSearchOption(decision.Options, dispatch.Option) {
return work.WorkGraph{}, nil, ErrInvalidSolutionSearchWave
}
seen[dispatch.Option] = struct{}{}
intent := dispatch.Intent
intent.SpecialistPurpose = string(dispatch.Option)
intents = append(intents, intent)
nodes = append(nodes, work.GraphNode{ID: work.GraphNodeID(fmt.Sprintf("%s-node-%d", request.GraphID, index+1)), DispatchID: intent.DispatchID, IdempotencyKey: fmt.Sprintf("%s:%s:%d", request.IdempotencyPrefix, dispatch.Option, decision.NextSearchRound), State: work.GraphNodeBlocked, Purpose: work.GraphNodePurposeGeneric})
}
if len(nodes) == 0 {
return work.WorkGraph{}, nil, ErrInvalidSolutionSearchWave
}
return work.WorkGraph{ID: request.GraphID, Revision: 1, State: work.GraphDraft, Nodes: nodes, Budget: request.Budget, ParentGraphID: request.ParentGraphID, ParentGraphRevision: request.ParentGraphRevision, TriggerEvidenceRef: request.TriggerEvidenceRef}, intents, nil
}
func containsSearchOption(options []work.SearchOptionKind, target work.SearchOptionKind) bool {
for _, option := range options {
if option == target {
return true
}
}
return false
}
+29
View File
@@ -1,6 +1,7 @@
package domain
import (
"fmt"
"git.cin.su/m/Assistant/contracts/work"
"testing"
)
@@ -28,3 +29,31 @@ func TestSolutionSearchStopsOnlyForCancelOrVerifiedCompletion(t *testing.T) {
t.Fatalf("cancel was not terminal: %#v %v", cancelled, err)
}
}
func TestBuildSolutionSearchWaveMaterializesParallelAgentDirections(t *testing.T) {
decision, err := DecideSolutionSearch(work.SolutionSearchInput{GoalID: "goal-1", GoalState: work.GoalInProgress, MaxRound: 1})
if err != nil {
t.Fatal(err)
}
options := []work.SearchOptionKind{work.SearchOptionAgents, work.SearchOptionCapability, work.SearchOptionResearch, work.SearchOptionReflection}
dispatches := make([]work.SolutionSearchDispatch, 0, len(options))
for i, option := range options {
dispatches = append(dispatches, work.SolutionSearchDispatch{Option: option, Intent: work.AgentDispatchIntent{DispatchID: workDispatchID(i), IdempotencyKey: workDispatchID(i) + ":idem"}})
}
graph, intents, err := BuildSolutionSearchWave(decision, work.SolutionSearchWaveRequest{GraphID: "graph-1", IdempotencyPrefix: "goal-1", Dispatches: dispatches, Budget: work.GraphBudget{MaxParallel: 4, MaxAttempts: 2}})
if err != nil {
t.Fatal(err)
}
if len(graph.Nodes) != 4 || len(intents) != 4 || graph.State != work.GraphDraft {
t.Fatalf("unexpected materialized wave: %#v %#v", graph, intents)
}
for i, node := range graph.Nodes {
if node.State != work.GraphNodeBlocked || intents[i].SpecialistPurpose != string(options[i]) {
t.Fatalf("wave direction not preserved: node=%#v intent=%#v", node, intents[i])
}
}
}
func workDispatchID(index int) string {
return fmt.Sprintf("dispatch-%d", index)
}