package agent import ( "context" "encoding/json" "strconv" "strings" "testing" "github.com/Autumn-27/artex/db" actool "github.com/Autumn-27/norma/tool" ) // guardTaskStore creates a throwaway task (PG) and returns its exploration store. // It has no goal node until the test adds one. func guardTaskStore(t *testing.T) *db.ExplorationStore { t.Helper() d := testDB(t) t.Cleanup(func() { _ = d.Close() }) task, err := d.CreateTaskWithOptions("agentic guards", "exercise the goal and hint guards", db.TaskCreateOptions{}) if err != nil { t.Fatal(err) } t.Cleanup(func() { _ = d.DeleteTask(task.ID) }) return d.Exploration(task.ExplorationID) } func callGuardTool(t *testing.T, tool actool.CoreTool, input string) actool.Result { t.Helper() res, err := tool.Call(context.Background(), json.RawMessage(input), nil) if err != nil { t.Fatalf("%s: transport error: %v", tool.Name(), err) } return res } func addGuardNode(t *testing.T, s *db.ExplorationStore, kind string, payload map[string]any, state string) int64 { t.Helper() id, err := s.AddNode(kind, payload, 0, state, "worker-1", nil) if err != nil { t.Fatal(err) } return id } func nodeState(t *testing.T, s *db.ExplorationStore, id int64) string { t.Helper() n, err := s.GetNode(id) if err != nil || n == nil { t.Fatalf("node %d: %v", id, err) } return n.State } // goal_met refuses while a goal node is open, and ends the task once every goal // is met (#124, F5). func TestGoalMetRefusesWhileGoalsOpen(t *testing.T) { s := guardTaskStore(t) open := addGuardNode(t, s, db.KindGoal, map[string]any{"text": "read the admin panel"}, "open") addGuardNode(t, s, db.KindGoal, map[string]any{"text": "list the users"}, "met") tsx := NewToolSet(s, "planner") res := callGuardTool(t, tsx.goalMet(), `{"reason":"the data says we are done"}`) if !res.IsError || !strings.Contains(res.Flatten(), "1 of 2 goals") || !strings.Contains(res.Flatten(), "prove_goal") { t.Fatalf("open goal: want a refusal naming the open goals and prove_goal, got IsError=%v %q", res.IsError, res.Flatten()) } if tsx.GoalMet { t.Fatal("goal_met set GoalMet while a goal is open") } if err := s.SetNodeState(open, "met"); err != nil { t.Fatal(err) } res = callGuardTool(t, tsx.goalMet(), `{"reason":"both goals proven"}`) if res.IsError || !tsx.GoalMet || tsx.Reason != "both goals proven" { t.Fatalf("all goals met: IsError=%v GoalMet=%v reason=%q %q", res.IsError, tsx.GoalMet, tsx.Reason, res.Flatten()) } } // A task without goal nodes keeps the old goal_met behavior. func TestGoalMetWithoutGoalNodes(t *testing.T) { tsx := NewToolSet(guardTaskStore(t), "planner") res := callGuardTool(t, tsx.goalMet(), `{"reason":"task goal reached"}`) if res.IsError || !tsx.GoalMet { t.Fatalf("no goal node: IsError=%v GoalMet=%v %q", res.IsError, tsx.GoalMet, res.Flatten()) } } // prove_goal accepts a fact only when its confidence is observed; a finding is // still accepted (#124, F5). func TestProveGoalRequiresObservedFact(t *testing.T) { s := guardTaskStore(t) goalA := addGuardNode(t, s, db.KindGoal, map[string]any{"text": "get admin"}, "open") goalB := addGuardNode(t, s, db.KindGoal, map[string]any{"text": "dump the users"}, "open") inferred := addGuardNode(t, s, db.KindFact, map[string]any{"summary": "admin is probably reachable", "confidence": "inferred"}, "confirmed") unlabeled := addGuardNode(t, s, db.KindFact, map[string]any{"summary": "admin reachable"}, "confirmed") observed := addGuardNode(t, s, db.KindFact, map[string]any{"summary": "logged in as admin", "confidence": " Observed "}, "confirmed") finding := addGuardNode(t, s, db.KindFinding, map[string]any{"summary": "user table dumped"}, "confirmed") tsx := NewToolSet(s, "planner") prove := func(goal, ev int64) actool.Result { return callGuardTool(t, tsx.proveGoal(), `{"goal_id":`+strconv.FormatInt(goal, 10)+`,"evidence_id":`+strconv.FormatInt(ev, 10)+`,"reason":"x"}`) } for name, ev := range map[string]int64{"inferred": inferred, "unlabeled": unlabeled} { res := prove(goalA, ev) if !res.IsError || !strings.Contains(res.Flatten(), "observed") || !strings.Contains(res.Flatten(), "stays open") { t.Fatalf("%s fact: want a refusal, got IsError=%v %q", name, res.IsError, res.Flatten()) } if st := nodeState(t, s, goalA); st != "open" { t.Fatalf("%s fact: goal state %q, want open", name, st) } } if tsx.GoalMet { t.Fatal("a refused proof set GoalMet") } if res := prove(goalA, observed); res.IsError || nodeState(t, s, goalA) != "met" { t.Fatalf("observed fact: IsError=%v state=%q %q", res.IsError, nodeState(t, s, goalA), res.Flatten()) } if tsx.GoalMet { t.Fatal("GoalMet set while goal B is open") } if res := prove(goalB, finding); res.IsError || nodeState(t, s, goalB) != "met" || !tsx.GoalMet { t.Fatalf("finding: IsError=%v state=%q GoalMet=%v %q", res.IsError, nodeState(t, s, goalB), tsx.GoalMet, res.Flatten()) } } // add_hint stores the calling ToolSet as the hint's origin and passes it to the // trigger (#124, F6): an orchestrator hint is not labelled human, and the main // agent (worker "human") still is. func TestAddHintRecordsOrigin(t *testing.T) { s := guardTaskStore(t) for _, origin := range []string{"orchestrator", "human"} { tsx := NewToolSet(s, origin) var gotOrigin string var gotTexts []string tsx.SetNotifyHint(func(o string, texts []string) { gotOrigin, gotTexts = o, texts }) res := callGuardTool(t, tsx.AddHintTool(), `{"text":"focus on the export endpoint"}`) out := res.Flatten() if res.IsError || !strings.HasPrefix(out, "hint added: ") { t.Fatalf("%s: add_hint failed: %q", origin, out) } id, err := strconv.ParseInt(strings.TrimPrefix(out, "hint added: "), 10, 64) if err != nil { t.Fatalf("%s: hint id in %q: %v", origin, out, err) } n, err := s.GetNode(id) if err != nil || n == nil || n.Kind != db.KindHint || n.Origin != origin { t.Fatalf("%s: hint node %+v err=%v, want origin %q", origin, n, err, origin) } if gotOrigin != origin || len(gotTexts) != 1 || gotTexts[0] != "focus on the export endpoint" { t.Fatalf("%s: trigger got origin=%q texts=%v", origin, gotOrigin, gotTexts) } } } // renderTriggers names the writer of a hint from its origin; only the main agent // is "the human" (#124, F6). The hint case never reads the store. Since F3 a hint // not written by the operator is framed as data. func TestRenderTriggersHintOrigin(t *testing.T) { env := newDataEnvelope() framed := "\n" + env.wrap("hints", "h1") + "\n" for origin, want := range map[string]string{ "human": "- [operator] The human (via the main agent) added a strategic hint: h1", "orchestrator": "- A cross-task orchestration added a strategic hint: " + framed, "worker-3": "- An agent (worker-3) added a strategic hint: " + framed, "": "- A source that was not recorded added a strategic hint: " + framed, } { got := renderTriggers([]TriggerEvent{{Kind: "hint", Hints: []string{"h1"}, HintOrigin: origin}}, env, triggerLookup{}) if !strings.Contains(got, want) || strings.Contains(got, "The human (main agent)") { t.Errorf("origin %q: got %q, want %q", origin, got, want) } } got := renderTriggers([]TriggerEvent{{Kind: "hint", Hints: []string{"h1", "h2"}, HintOrigin: "orchestrator"}}, env, triggerLookup{}) if !strings.Contains(got, "- A cross-task orchestration added 2 strategic hints: \n"+env.wrap("hints", "h1; h2")) { t.Errorf("batch: got %q", got) } }